Exceptions : expression try...with (F#)

Cette rubrique décrit l'expression try...with qui est utilisée pour la gestion des exceptions en langage F#.

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

Notes

L'expression try...with est utilisée pour gérer les exceptions en F#. Il est semblable à 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 pattern est ensuite comparé à l'exception, et pour le premier modèle correspondant, l'expression correspondante, appelée gestionnaire d'exceptions, est exécutée pour cette branche, et l'expression globale retourne la valeur de l'expression dans ce gestionnaire d'exceptions. Si aucun modèle ne correspond, l'exception se propage à la pile des appels jusqu'à ce qu'un gestionnaire correspondant soit trouvé. Les types des valeurs retournées de chaque expression dans les gestionnaires d'exceptions doivent correspondre au type retourné de l'expression dans le bloc try.

Souvent, le fait qu'une erreur se soit produite signifie également qu'aucune valeur valide ne peut être retournée des expressions dans 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 des exceptions F#. Vous pouvez définir des exceptions F# à l'aide du mot clé exception.

Vous pouvez utiliser divers modèles pour filtrer selon le type d'exception et d'autres conditions ; les options sont résumées dans le tableau suivant.

Modèle	Description
:? exception-type	Correspond au type d'exception .NET spécifié.
:? exception-type as identifier	Correspond au type d'exception .NET spécifié, mais donne une valeur nommée à l'exception.
exception-name(arguments)	Correspond à un type d'exception F# et lie les arguments.
identifier	Correspond à une exception et lie le nom à l'objet exception. Équivalent à :? System.Exception as identifier
identifier when condition	Correspond à une exception si la condition est remplie.

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

Notes

La construction try...with est une expression séparée de l'expression try...finally.Par conséquent, si votre code requiert à la fois un bloc with et un bloc finally, vous devrez imbriquer les deux expressions.

Notes

Vous pouvez utiliser try...with dans les flux de travail asynchrones et autres expressions de calcul, auquel cas une version personnalisée de l'expression try...with est utilisée.Pour plus d'informations, consultez Workflows asynchrones (F#) et Expressions de calcul (F#).

Voir aussi

Référence

Types d'exceptions (F#)

Exceptions : expression try...finally (F#)

Autres ressources

Gestion des exceptions (F#)