F # - Tratamento de exceções

Uma exceção é um problema que surge durante a execução de um programa. Uma exceção F # é uma resposta a uma circunstância excepcional que surge durante a execução de um programa, como uma tentativa de divisão por zero.

As exceções fornecem uma maneira de transferir o controle de uma parte de um programa para outra. O tratamento de exceções F # fornece as seguintes construções -

Construir	Descrição
aumentar expr	Gera a exceção fornecida.
failwith expr	Levanta o System.Exception exceção.
tente expr com regras	Captura expressões que correspondem às regras de padrão.
tente expr finalmente expr	Execução do finally expressão quando o cálculo é bem-sucedido e quando uma exceção é levantada.
| :? ArgumentException	Uma regra que corresponde ao tipo de exceção .NET fornecido.
| :? ArgumentException as e	Uma regra que corresponde ao tipo de exceção .NET fornecido, vinculando o nome e para o valor do objeto de exceção.
| Falha (msg) → expr	Uma regra que corresponde à exceção F # de transporte de dados fornecida.
| exn → expr	Uma regra que corresponde a qualquer exceção, vinculando o nome exn para o valor do objeto de exceção.
| exn quando expr → expr	Uma regra que corresponde à exceção sob a condição fornecida, vinculando o nome exn para o valor do objeto de exceção.

Vamos começar com a sintaxe básica do Tratamento de Exceções.

Sintaxe

A sintaxe básica para o bloco de tratamento de exceções F # é -

exception exception-type of argument-type

Onde,

• exception-type é o nome de um novo tipo de exceção F #.

• argument-type representa o tipo de um argumento que pode ser fornecido quando você levanta uma exceção desse tipo.

• Vários argumentos podem ser especificados usando um tipo de tupla para o tipo de argumento.

o try...with expressão é usada para tratamento de exceções na linguagem F #.

A sintaxe para tentar ... com expressão é -

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

o try...finally expression permite que você execute código de limpeza mesmo se um bloco de código lançar uma exceção.

Sintaxe para a tentativa ... finalmente a expressão é -

try
   expression1
finally
   expression2

o raiseA função é usada para indicar que ocorreu um erro ou condição excepcional. Ele também captura as informações sobre o erro em um objeto de exceção.

A sintaxe para a função de aumento é -

raise (expression)

o failwith função gera uma exceção F #.

A sintaxe para a função failwith é -

failwith error-message-string

o invalidArg função gera uma exceção de argumento.

invalidArg parameter-name error-message-string

Exemplo de tratamento de exceções

Exemplo 1

O programa a seguir mostra o tratamento básico de exceções com uma simples tentativa ... com bloco -

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

let result1 = divisionprog 100 0

Quando você compila e executa o programa, ele produz a seguinte saída -

Division by zero!

Exemplo 2

F # fornece um exceptiontipo para declarar exceções. Você pode usar um tipo de exceção diretamente nos filtros em umtry...with expressão.

O exemplo a seguir demonstra isso -

exception Error1 of string
// Using a tuple type as the argument type.
exception Error2 of string * int

let myfunction x y =
   try
      if x = y then raise (Error1("Equal Number Error"))
      else raise (Error2("Error Not detected", 100))
   with
      | Error1(str) -> printfn "Error1 %s" str
      | Error2(str, i) -> printfn "Error2 %s %d" str i
myfunction 20 10
myfunction 5 5

Quando você compila e executa o programa, ele produz a seguinte saída -

Error2 Error Not detected 100
Error1 Equal Number Error

Exemplo 3

O exemplo a seguir demonstra o tratamento de exceções aninhadas -

exception InnerError of string
exception OuterError of string

let func1 x y =
   try
      try
         if x = y then raise (InnerError("inner error"))
         else raise (OuterError("outer error"))
      with
         | InnerError(str) -> printfn "Error:%s" str
   finally
      printfn "From the finally block."

let func2 x y =
   try
      func1 x y
   with
      | OuterError(str) -> printfn "Error: %s" str

func2 100 150
func2 100 100
func2 100 120

Quando você compila e executa o programa, ele produz a seguinte saída -

From the finally block.
Error: outer error
Error:inner error
From the finally block.
From the finally block.
Error: outer error

Exemplo 4

A função a seguir demonstra o failwith função -

let divisionFunc x y =
   if (y = 0) then failwith "Divisor cannot be zero."
   else
      x / y

let trydivisionFunc x y =
   try
      divisionFunc x y
   with
      | Failure(msg) -> printfn "%s" msg; 0

let result1 = trydivisionFunc 100 0
let result2 = trydivisionFunc 100 4
printfn "%A" result1
printfn "%A" result2

Quando você compila e executa o programa, ele produz a seguinte saída -

Divisor cannot be zero.
0
25

Exemplo 5

o invalidArgfunção gera uma exceção de argumento. O programa a seguir demonstra isso -

let days = [| "Sunday"; "Monday"; "Tuesday"; "Wednesday"; "Thursday"; "Friday"; "Saturday" |]
let findDay day =
   if (day > 7 || day < 1)
      then invalidArg "day" (sprintf "You have entered %d." day)
   days.[day - 1]

printfn "%s" (findDay 1)
printfn "%s" (findDay 5)
printfn "%s" (findDay 9)

Quando você compila e executa o programa, ele produz a seguinte saída -

Sunday
Thursday
Unhandled Exception:
System.ArgumentException: You have entered 9.
…

Algumas outras informações sobre o arquivo e a variável que causam o erro no sistema também serão exibidas, dependendo do sistema.