Exceptions : La tentative... avec expression

Cette rubrique décrit l’expression try...with , l’expression utilisée pour la gestion des exceptions dans F#.

Syntaxe

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

Remarques

L’expression try...with est utilisée pour gérer les exceptions dans F#. Il est similaire à l’instruction try...catch en C#. Dans la syntaxe précédente, le code dans expression1 peut générer une exception. L’expression try...with retourne une valeur. Si aucune exception n’est levée, l’expression entière retourne la valeur d’expression1. Si une exception est levée, chaque modèle est comparé à son tour à l’exception, et pour le premier modèle correspondant, l’expression correspondante, appelée gestionnaire d’exceptions, pour cette branche est exécutée, et l’expression globale retourne la valeur de l’expression dans ce gestionnaire d’exceptions. Si aucun modèle ne correspond, l’exception propage la pile des appels jusqu’à ce qu’un gestionnaire correspondant soit trouvé. Les types des valeurs retournées par chaque expression dans les gestionnaires d’exceptions doivent correspondre au type retourné par l’expression dans le try bloc.

Fréquemment, le fait qu’une erreur s’est produite signifie également qu’il n’existe aucune valeur valide qui peut être retournée à partir des expressions de chaque gestionnaire d’exceptions. Un modèle fréquent consiste à avoir le type de l’expression comme type d’option. L’exemple de code suivant illustre ce modèle.

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

let result1 = divide1 100 0

Les exceptions peuvent être des exceptions .NET, ou elles peuvent être des exceptions F#. Vous pouvez définir des exceptions F# à l’aide du exception mot clé.

Vous pouvez utiliser un large éventail de modèles pour filtrer sur le type d’exception et d’autres conditions ; les options sont résumées dans le tableau suivant.

Exemples

Les exemples de code suivants illustrent l’utilisation des différents modèles de gestionnaire d’exceptions.

// 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

Voir aussi

• gestion des exceptions
• Types d’exceptions
• Exceptions : l’expression try...finally