Exceções: O bloco try... com a expressão (F#)

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

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

Comentários

O try...with expressão é usada para tratar exceções em F#. É semelhante do try...catch instrução em C#. Na sintaxe anterior, o código de 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 o manipulador de exceção, essa ramificação é executada e a expressão geral retorna o valor da expressão desse 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 de manipuladores de exceção devem coincidir com o tipo retornado a expressão de 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 de 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# de exceções. Você pode definir exceções de F# 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.

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

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

Observação
Você pode usar try...with em fluxos de trabalho assíncronos e outros 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ções (F#)

Exceções: O bloco try... finalmente expressão (F#)

Outros recursos

Exceção de tratamento (F#)