F # - Ausnahmebehandlung

Eine Ausnahme ist ein Problem, das während der Ausführung eines Programms auftritt. Eine F # -Ausnahme ist eine Reaktion auf einen außergewöhnlichen Umstand, der während der Ausführung eines Programms auftritt, z. B. den Versuch, durch Null zu teilen.

Ausnahmen bieten eine Möglichkeit, die Kontrolle von einem Teil eines Programms auf einen anderen zu übertragen. Die Behandlung von F # -Ausnahmen bietet die folgenden Konstrukte:

Bauen	Beschreibung
expr. erhöhen	Löst die angegebene Ausnahme aus.
scheitern mit expr	Erhöht die System.Exception Ausnahme.
versuche es mit Regeln	Fängt Ausdrücke ab, die den Musterregeln entsprechen.
versuchen Sie es endlich mit Ausdruck	Ausführung der finally Ausdruck sowohl bei erfolgreicher Berechnung als auch bei Auslösung einer Ausnahme.
| :? ArgumentException	Eine Regel, die dem angegebenen .NET-Ausnahmetyp entspricht.
| :? ArgumentException als e	Eine Regel, die dem angegebenen .NET-Ausnahmetyp entspricht und den Namen bindet e auf den Ausnahmeobjektwert.
| Fehler (msg) → Ausdruck	Eine Regel, die mit der angegebenen datenführenden F # -Ausnahme übereinstimmt.
| exn → expr	Eine Regel, die mit einer Ausnahme übereinstimmt und den Namen bindet exn auf den Ausnahmeobjektwert.
| exn wenn expr → expr	Eine Regel, die unter der angegebenen Bedingung mit der Ausnahme übereinstimmt und den Namen bindet exn auf den Ausnahmeobjektwert.

Beginnen wir mit der grundlegenden Syntax der Ausnahmebehandlung.

Syntax

Die grundlegende Syntax für den F # -Ausnahmebehandlungsblock lautet -

exception exception-type of argument-type

Wo,

• exception-type ist der Name eines neuen F # -Ausnahmetyps.

• argument-type stellt den Typ eines Arguments dar, das angegeben werden kann, wenn Sie eine Ausnahme dieses Typs auslösen.

• Mithilfe eines Tupeltyps für den Argumenttyp können mehrere Argumente angegeben werden.

Das try...with Ausdruck wird für die Ausnahmebehandlung in der Sprache F # verwendet.

Syntax für den Versuch… mit Ausdruck ist -

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

Das try...finally Mit expression können Sie Bereinigungscode ausführen, auch wenn ein Codeblock eine Ausnahme auslöst.

Syntax für den Versuch ... endlich ist der Ausdruck -

try
   expression1
finally
   expression2

Das raiseDie Funktion zeigt an, dass ein Fehler oder eine Ausnahmebedingung aufgetreten ist. Außerdem werden die Informationen zum Fehler in einem Ausnahmeobjekt erfasst.

Die Syntax für die Raise-Funktion lautet -

raise (expression)

Das failwith Funktion erzeugt eine F # -Ausnahme.

Die Syntax für die Failwith-Funktion lautet -

failwith error-message-string

Das invalidArg Funktion generiert eine Argumentausnahme.

invalidArg parameter-name error-message-string

Beispiel für die Ausnahmebehandlung

Beispiel 1

Das folgende Programm zeigt die grundlegende Ausnahmebehandlung mit einem einfachen Versuch… mit Block -

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

let result1 = divisionprog 100 0

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Division by zero!

Beispiel 2

F # bietet eine exceptionTyp zum Deklarieren von Ausnahmen. Sie können einen Ausnahmetyp direkt in den Filtern in a verwendentry...with Ausdruck.

Das folgende Beispiel zeigt dies -

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

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Error2 Error Not detected 100
Error1 Equal Number Error

Beispiel 3

Das folgende Beispiel zeigt die Behandlung verschachtelter Ausnahmen -

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

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

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

Beispiel 4

Die folgende Funktion demonstriert die failwith Funktion -

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

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Divisor cannot be zero.
0
25

Beispiel 5

Das invalidArgFunktion generiert eine Argumentausnahme. Das folgende Programm demonstriert dies -

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)

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

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

Abhängig vom System werden auch einige andere Informationen zu der Datei und der Variablen angezeigt, die Fehler im System verursachen.