Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Eccezioni: espressione try...with (F#)

In questo argomento viene descritta l'espressione try...with, utilizzata per la gestione delle eccezioni nel linguaggio F#.

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

L'espressione try...with viene utilizzata per gestire eccezioni in F#. È simile all'istruzione in C# try...catch. Nella sintassi precedente il codice in expression1 potrebbe generare un'eccezione. L'espressione try...with restituisce un valore. Se non viene generata alcuna eccezione, l'intera espressione restituisce il valore di expression1. Se viene generata un'eccezione, ogni elemento pattern viene confrontato a turno con l'eccezione e, quando viene trovato il primo modello corrispondente, viene eseguito l'elemento expression corrispondente, noto come gestore di eccezioni per il ramo e l'espressione complessiva restituisce il valore dell'espressione in tale gestore di eccezioni. Se non corrisponde alcun modello, l'eccezione si propaga verso l'alto nello stack di chiamate fino a quando non viene trovato un gestore corrispondente. I tipi dei valori restituiti da ogni espressione nei gestori di eccezioni devono corrispondere al tipo restituito dall'espressione nel blocco try.

Spesso quando si verifica un errore significa anche che non vi è alcun valore valido che può essere restituito dalle espressioni in ogni gestore di eccezioni. Un modello frequente prevede che il tipo dell'espressione sia un tipo di opzione. Nell'esempio di codice seguente viene illustrato questo modello.


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

let result1 = divide1 100 0


Le eccezioni possono essere eccezioni .NET o F#. È possibile definire le eccezioni F# utilizzando la parola chiave exception.

È possibile utilizzare diversi modelli per filtrare il tipo di eccezione e altre condizioni. Le opzioni sono riepilogate nella tabella seguente.

Modello

Descrizione

:? exception-type

Trova la corrispondenza con il tipo di eccezione .NET specificato.

:? exception-type as identifier

Trova la corrispondenza con il tipo di eccezione .NET specificato, ma assegna all'eccezione un valore denominato.

exception-name(arguments)

Trova la corrispondenza con un tipo di eccezione F# e associa gli argomenti.

identifier

Trova la corrispondenza con qualsiasi eccezione e associa il nome all'oggetto eccezione. Uguale all':? System.Exception as identificatore

identifier when condition

Trova la corrispondenza con qualsiasi eccezione, se la condizione è vera.

Nell'esempio di codice seguente viene illustrato l'utilizzo dei diversi modelli di gestori di eccezioni.


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


Nota Nota

Il costrutto try...with è un'espressione distinta dall'espressione try...finally. Se pertanto nel codice sono necessari sia il blocco with che il blocco finally, sarà necessario annidare le due espressioni.

Nota Nota

È possibile utilizzare try...with in flussi di lavoro asincroni e altre espressioni di calcolo, nel qual caso viene utilizzata una versione personalizzata dell'espressione try...with. Per ulteriori informazioni, vedere Flussi di lavoro asincroni (F#) e Espressioni di calcolo (F#).

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft