F # - Traitement des exceptions

Une exception est un problème qui survient lors de l'exécution d'un programme. Une exception F # est une réponse à une circonstance exceptionnelle qui survient lors de l'exécution d'un programme, comme une tentative de division par zéro.

Les exceptions fournissent un moyen de transférer le contrôle d'une partie d'un programme à une autre. La gestion des exceptions F # fournit les constructions suivantes -

Construction La description
augmenter expr Déclenche l'exception donnée.
échec avec expr Augmente le System.Exception exception.
essayez expr avec des règles Attrape les expressions correspondant aux règles du modèle.
essayer expr enfin expr Exécution le finally expression à la fois lorsque le calcul est réussi et lorsqu'une exception est déclenchée.
| :? ArgumentException Une règle correspondant au type d'exception .NET donné.
| :? ArgumentException comme e Une règle correspondant au type d'exception .NET donné, liant le nom e à la valeur de l'objet d'exception.
| Échec (msg) → expr Une règle correspondant à l'exception F # portant des données donnée.
| exn → expr Une règle correspondant à n'importe quelle exception, liant le nom exn à la valeur de l'objet d'exception.
| exn quand expr → expr Une règle correspondant à l'exception sous la condition donnée, liant le nom exn à la valeur de l'objet d'exception.

Commençons par la syntaxe de base de la gestion des exceptions.

Syntaxe

La syntaxe de base du bloc de gestion des exceptions F # est -

exception exception-type of argument-type

Où,

  • exception-type est le nom d'un nouveau type d'exception F #.

  • argument-type représente le type d'un argument qui peut être fourni lorsque vous déclenchez une exception de ce type.

  • Plusieurs arguments peuvent être spécifiés à l'aide d'un type tuple pour le type d'argument.

le try...with expression est utilisée pour la gestion des exceptions dans le langage F #.

La syntaxe de l'essai… avec expression est -

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

le try...finally expression vous permet d'exécuter du code de nettoyage même si un bloc de code lève une exception.

La syntaxe de l'expression try… finally est -

try
   expression1
finally
   expression2

le raiseLa fonction est utilisée pour indiquer qu'une erreur ou une condition exceptionnelle s'est produite. Il capture également les informations sur l'erreur dans un objet d'exception.

La syntaxe de la fonction de montée est -

raise (expression)

le failwith La fonction génère une exception F #.

La syntaxe de la fonction failwith est -

failwith error-message-string

le invalidArg La fonction génère une exception d'argument.

invalidArg parameter-name error-message-string

Exemple de gestion des exceptions

Exemple 1

Le programme suivant montre la gestion des exceptions de base avec un simple essai… avec bloc -

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

let result1 = divisionprog 100 0

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Division by zero!

Exemple 2

F # fournit un exceptiontype pour déclarer des exceptions. Vous pouvez utiliser un type d'exception directement dans les filtres d'untry...with expression.

L'exemple suivant illustre ceci -

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

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Error2 Error Not detected 100
Error1 Equal Number Error

Exemple 3

L'exemple suivant illustre la gestion des exceptions imbriquées -

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

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

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

Exemple 4

La fonction suivante montre le failwith fonction -

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

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

Divisor cannot be zero.
0
25

Exemple 5

le invalidArgLa fonction génère une exception d'argument. Le programme suivant le démontre -

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)

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

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

Certaines autres informations sur le fichier et la variable à l'origine de l'erreur dans le système seront également affichées, selon le système.