Exceções: a expressão try...with (F#)

Artigo
06/10/2015

Este tópico descreve o try...with expressão, a expressão usada para tratamento de exceção no idioma F#.

try
 expression1
with
  | pattern1 -> expression2
  | pattern2 -> expression3
  ...

Comentários

O try...with expressão é usada para tratar exceções em F#. Ele é semelhante do try...catch instrução em C#. Na sintaxe anterior, o código em expression1 pode gerar uma exceção. O try...with expressão retorna um valor. Se nenhuma exceção é lançada, a expressão inteira retorna o valor de expression1. Se uma exceção é lançada, cada pattern é comparado por sua vez, com a exceção e para o primeiro padrão correspondente, o correspondente expression, conhecido como o manipulador de exceção, para a ramificação é executada e a expressão geral retorna o valor da expressão nesse manipulador de exceção. Não se corresponder a nenhum padrão, a exceção se propaga para cima a pilha de chamadas até que um manipulador correspondente seja encontrado. Os tipos de valores retornados de cada expressão nos manipuladores de exceção devem coincidir com o tipo retornado a expressão na try bloco.

Freqüentemente, o fato de que ocorreu um erro também significa que não há nenhum valor válido que pode ser retornado de expressões em cada manipulador de exceção. Um padrão freqüente é ter o tipo da expressão a ser um tipo de opção. O exemplo de código a seguir ilustra esse padrão.

let divide1 x y =
   try
      Some (x / y)
   with
      | :? System.DivideByZeroException -> printfn "Division by zero!"; None

let result1 = divide1 100 0

Exceções podem ser.NET específicas, ou eles podem ser F# exceções. Você pode definir F# exceções usando o exception palavra-chave.

Você pode usar uma variedade de padrões para filtrar o tipo de exceção e outras condições; as opções são resumidas na tabela a seguir.

Padrão	Descrição
:? exception-type	Corresponde ao especificado.Tipo de exceção de NET.
:? exception-typecomoidentifier	Corresponde ao especificado.NET tipo de exceção, mas oferece a exceção a um valor nomeado.
exception-name(arguments)	Corresponde a um tipo de exceção F# e vincula os argumentos.
identifier	Corresponde a qualquer exceção e vincula o nome para o objeto de exceção. Equivalente a :? System.Exception as identificador
identifierQuandocondition	Corresponde a qualquer exceção se a condição for verdadeira.

Exemplos

Os exemplos de código a seguir ilustram o uso dos vários padrões de manipulador de exceção.

// This example shows the use of the as keyword to assign a name to a 
// .NET exception. 
let divide2 x y =
  try
    Some( x / y )
  with
    | :? System.DivideByZeroException as ex -> printfn "Exception! %s " (ex.Message); None

// This version shows the use of a condition to branch to multiple paths 
// with the same exception. 
let divide3 x y flag =
  try
     x / y
  with
     | ex when flag -> printfn "TRUE: %s" (ex.ToString()); 0
     | ex when not flag -> printfn "FALSE: %s" (ex.ToString()); 1

let result2 = divide3 100 0 true 

// This version shows the use of F# exceptions. 
exception Error1 of string
exception Error2 of string * int

let function1 x y =
   try 
      if x = y then raise (Error1("x"))
      else raise (Error2("x", 10))
   with
      | Error1(str) -> printfn "Error1 %s" str
      | Error2(str, i) -> printfn "Error2 %s %d" str i

function1 10 10
function1 9 2

Dica

O try...with construção é uma expressão separada da try...finally expressão.Portanto, se seu código requer que ambos um with bloco e um finally bloco, você terá que aninhar as duas expressões.

Dica

Você pode usar try...with em fluxos de trabalho assíncronos e outras computação expressões, nesse caso uma versão personalizada da try...with a expressão é usada.Para obter mais informações, consulte Fluxos de trabalho assíncronos (F#) e Expressões de computação (F#).

Consulte também

Referência

Tipos de exceção (F#)

Exceções: a expressão try...finally (F#)

Outros recursos

Tratamento de exceções (F#)

Compartilhar via