Ausnahmen Exceptions Definition Ausnahmen erzeugen Ausnahmen abfangen Ausnahmen weiterleiten Dr. Beatrice Amrhein

Definition

Definition: Ausnahme (Exception) In C# werden Fehler, die zur Laufzeit im Programm auftreten, über Ausnahmen (Exceptions) übermittelt. Dies können Fehler aus dem System, (Benutzer-)Eingabefehler oder Laufzeitfehler sein Sobald eine Ausnahme ausgelöst wird, wird sie in der Aufrufliste so lange aufwärts weitergeleitet, bis eine Fehlerbehandlung (catch-Anweisung) für die Ausnahme gefunden wird. Nicht abgefangene Ausnahmen werden vom System (bzw. der Laufzeit-Umgebung) in einem Dialogfeld als «nicht behandelte Ausnahme» anzeigt.

Definition: Ausnahme (Exception) Alle Ausnahmen werden durch Fehler-Klassen dargestellt. Alle Ausnahmen werden von der Basisklasse System.Exception abgeleitet. Die Fehler-Klasse bestimmt den Typ/die Art der Ausnahme und enthält Eigenschaften mit Details über die Ausnahme. Ausnahmen werden mit dem throw Schlüsselwort „geworfen“ (ausgeliefert). Werfen einer allgemeinen Ausnahme throw new System.Exception();

Beispiele von Ausnahmen/Fehlern Beschreibung ArithmeticException Ausnahmen, die während arithmetischer Operationen ausgelöst werden, z. B. DivideByZeroException oder OverflowException. DivideByZeroException Wird ausgelöst, wenn versucht wird, einen ganzzahligen Wert durch 0 zu teilen. IndexOutOfRangeException Wird ausgelöst, wenn versucht wird, ein Array mit einem Index zu indizieren, der kleiner als 0 ist oder ausserhalb der Grenzen des Arrays liegt. InvalidCastException Wird ausgelöst, wenn eine explizite Konvertierung von einem Basistyp in einen Schnittstellentyp oder in einen abgeleiteten Typ zur Laufzeit fehlschlägt. NullReferenceException Wird ausgelöst, wenn ein Objekt referenziert wird, dessen Wert NULL ist. StackOverflowException Wird ausgelöst, wenn der Ausführungsstapel durch zu viele anstehende Methodenaufrufe ausgelastet ist. Im Normalfall deutet dies auf eine zu tiefe Rekursion oder eine Endlosschleife hin. Nach dem Handbuch der .NET 4.0-Programmierung, Rolf Wenger, 2012

Die Ableitungshierarche der Exceptions Alle Exception-Klassen sind von der Basisklasse Exception abgeleitet und erben daher die Message Property und die ToString() Methode von Exception

Ausnahmen erzeugen

Methode mit Ausnahme Dies ist eine Methode, welche bei negativem Eingabeparameter (mit throw) eine Exception wirft. public void MethodeMitAusnahme(int p) { Console.WriteLine("Beginn der Methode mit Parameter {0}", p); if (p < 0) throw new System.Exception(); } Console.WriteLine("Ende der Methode mit Parameter {0}", p);

Methode mit Ausnahme public void MethodeMitAusnahme(int p) { Console.WriteLine("Beginn der Methode mit Parameter {0}", p); if (p < 0) throw new System.Exception(); } Console.WriteLine("Ende der Methode mit Parameter {0}", p); static void Main(string[] args) { TestKlasse test = new TestKlasse(); test.MethodeMitException(1); test.MethodeMitException(-1); }

Methode mit Ausnahme Falls eine Exception geworfen wird, wird der Programm-Verlauf abgebrochen und die Methode sofort verlassen. Falls die aufrufende Methode die Exception nicht behandelt, wird das Programm mit einer Fehlermeldung (Laufzeitfehler) abgebrochen. public void MethodeMitAusnahme(int p) { Console.WriteLine("Beginn der Methode mit Parameter {0}", p); if (p < 0) throw new System.Exception(); } Console.WriteLine("Ende der Methode mit Parameter {0}", p); Ausnahme bricht den Verlauf hier ab p >= 0

Methode mit Ausnahme Falls eine Exception (Ausnahme) geworfen wird, wird der Programm-Verlauf abgebrochen und die Methode verlassen. Falls die aufrufende Methode die Ausnahme nicht behandelt, wird das Programm mit einer Fehlermeldung (Laufzeitfehler) abgebrochen. public void MethodeMitAusnahme(int p) { Console.WriteLine("Beginn der Methode mit Parameter {0}", p); if (p < 0) throw new System.Exception(); } Console.WriteLine("Ende der Methode mit Parameter {0}", p); p >= 0 Ausnahme bricht das Programm ab

Exceptions / Ausnahmen behandeln

try und catch Zum Abfangen von (ev. auftretenden) Exceptions wird der Bereich, in welchem die Ausnahme entstehen könnte, mit Hilfe von try eingeschlossen. catch „fängt“ eine so geworfene Exception auf und behandelt diese, zum Beispiel durch Ausgabe einer Fehlermeldung auf die Console. try { tue etwas tue etwas, was ev. eine Exception wirft tue noch etwas, was ev. eine Exception wirft } catch ( die geworfene Exception ) behandle die Exception

Beispiel: Division mit Exception Die TestKlasse hat eine Divisions-Methode, welche beim Versuch einer Division mit 0 eine Exception wirft. class TestKlasse { public double Division(double x, double y) if (y == 0) throw new DivideByZeroException(); return x / y; }

Beispiel: Division mit Exception Das Einfassen des Divisions-Aufrufs in einen try-Block und das Abfangen der Exception mit einem catch Block verhindert das Auftreten eines (eventuellen) Laufzeitfehlers. try { t.Division(a, b)); } catch (DivideByZeroException e) Console.WriteLine("Versuchte Division von {0} durch {1}", a, b);

Beispiel: Division mit Exception Eingebettet in das Main Programm: public static void Main(string[] args) { TestKlasse t = new TestKlasse(); double a = 3.2; double b = 0; try t.Division(a, b)); } catch (DivideByZeroException e) Console.WriteLine("Versuchte Division von {0} durch {1}", a, b);

Beispiel: Vektor Bereichs-Überlauf Falls der folgenden Methode ein Vektor mit weniger als 4 Stellen übergeben wird, greift vektor[i] auf einen ungültigen Bereich zu. Dies wirft eine IndexOutOfRangeException. public double VektorDurchlauf(int[] vektor) { double resultat = 0; for (int i = 0; i <= 3; i++) resultat += vektor[i]; } return resultat;

Beispiel: Vektor Bereichs-Überlauf Auf die folgende Art kann die geworfene IndexOutOfRangeException abgefangen und eine Fehlermeldung auf die Console geschrieben werden. public static void Main(string[] args) { int[] vektor = { 1, 2, 3 }; TestKlasse t = new TestKlasse(); try t.VektorDurchlauf(vektor); } catch (IndexOutOfRangeException e) Console.WriteLine("VektorDurchlauf hat gültigen Bereich überschritten");

Regeln für Ausnahmen Verwenden Sie einen try-Block um Anweisungen herum, welche eventuell eine Ausnahmen generieren können. Sobald eine Ausnahme im try-Block auftritt, springt die Ablaufsteuerung zur nächsten passenden Ausnahme-Behandlung. In C# wird die Ausnahme-Behandlung mit dem catch-Schlüsselwort definiert. Falls für eine bestimmte Ausnahme keine Ausnahme-Behandlung vorhanden ist, wird die Ausführung des Programms mit einer Fehlermeldung (Dialog-Fenster) angehalten.

Falsche Ausnahme-Behandlung Hier wird eine IndexOutOfRangeException geworfen. Gefangen würde aber eine DivideByZeroException. public static void Main(string[] args) { int[] vektor = { 1, 2, 3 }; TestKlasse t = new TestKlasse(); try t.VektorDurchlauf(vektor); } catch (DivideByZeroException e) Console.WriteLine("Fehler"); ???

Falsche Ausnahme-Behandlung Hier wird eine IndexOutOfRangeException geworfen. Gefangen würde aber eine DivideByZeroException. Die IndexOutOfRangeException verursacht darum einen Laufzeitfehler. public static void Main(string[] args) { int[] vektor = { 1, 2, 3 }; TestKlasse t = new TestKlasse(); try t.VektorDurchlauf(vektor); } catch (DivideByZeroException) Console.WriteLine("Fehler"); ???

Eigene, spezifische Ausnahme-Klassen definieren

Spezifische Exceptions Das Fangen von Exception (der Basisklasse aller Exceptions) behandelt alle Fehler. Allerdings ist dann nicht klar, welche Art von Exception aufgetreten ist und wie diese behandelt werden kann. Durch das Definieren von möglichst spezifischen (eigenen) Exception-Klassen, kann man exakte Informationen über den Typ des Fehlers erhalten. Eigene Exceptions können ausführliche Informationen zum Fehler, z. B. den Zustand der Aufrufliste (wo genau ist der Fehler passiert) und eine Textbeschreibung des Fehlers enthalten.

Eigene Ausnahme implementieren und benutzen Die Klasse ParameterFehler ist von Exception abgeleitet und implementiert eine eigene, spezifische Ausnahme, die für Fehleingaben von Benutzern verwendet werden kann. Der Basiskonstruktor Exception(String message) speichert die Fehlermeldung. public class ParameterFehler : Exception { public ParameterFehler(String message) : base("Ungültige Parameter: " + message) } // Fehlermeldung abspeichern

Verwenden der eigenen Exception-Klasse Der Konstruktor von GeomFigur wirft bei der Eingabe von negativen Seitenlängen einen ParameterFehler (mit einer entsprechenden Fehlermeldung). protected GeomFigur(double a, double b) { if (a <= 0 || b <= 0) String meldung = String.Format("Seiten: a={0}, b={1}", a, b); throw new ParameterFehler(meldung); } this.a = a; this.b = b;

Abfangen der eigenen Exception-Klasse class Program { static void Main(string[] args) try Rechteck r = new Rechteck(-1.3, 2.4); } catch (ParameterFehler e) Console.WriteLine(e.ToString()); Der Konstruktor von Rechteck ruft den Basis-Konstruktor GeomFigur auf, welcher eine Ausnahme wirft. Der catch-Block fängt die Ausnahme auf und gibt alle verfügbaren Informationen auf die Console aus.

Eigene Ausnahme mit überladenem Konstruktor Die Klasse EingabeFehler hat einen überladenen Konstruktor. Der zweite Konstruktor hat zum exakteren Ausgeben des Fehlers einen zusätzlichen optionalen Parameter, welcher weitere Informationen zum aufgetretenen Fehler ausgeben kann. public class EingabeFehler : Exception { public EingabeFehler(String meldung) : base(meldung) { } public EingabeFehler(String meldung, params Object[] p) : base(String.Format(meldung, p)) }

Eigene Ausnahme EingabeFehler benutzen public class TestKlasse { public static int Eingabe() String eingabe = Console.ReadLine(); char[] c = eingabe.ToCharArray(); if (c[0] < '0' || c[0] > '9') throw new EingabeFehler("Eingabe '{0}' ist keine Zahl\n", c[0]); } int nummer = int.Parse(eingabe); return nummer; Benutzen des zweiten Konstruktors

Ausnahme abfangen und Fehlermeldung ausgeben static void Main(string[] args) { try Console.WriteLine("Erste Zahl eingeben"); int nummer1 = TestKlasse.Eingabe(); Console.WriteLine("Zweite Zahl eingeben"); int nummer2 = TestKlasse.Eingabe(); } catch (EingabeFehler e) Console.WriteLine(e.ToString()); Die Eingabe-Methode der TestKlasse versucht eine Nummer zu lesen und wirft im Fehlerfall eine Ausnahme Der catch-Block fängt die Ausnahme auf und gibt alle verfügbaren Informationen auf die Console aus.

try - finally

finally Code in einem finally-Block wird immer ausgeführt, egal ob eine Exception ausgelöst wurde oder nicht. Verwenden Sie einen finally-Block um den Ablauf sauber zu beenden um Ressourcen freizugeben, z. B. zum Setzen von null (falls nötig) oder zum Schliessen von im try-Block geöffneten Streams oder Dateien Um lokale Informationen auszugeben

TestMethode mit finally public class TestKlasse { public void TestMethode(String s) try int i = int.Parse(s); Console.WriteLine("Division: 2/{0}={1}", i, 2 / i); } finally Console.Write("\nDie Eingabe war: {0}\n", s); Exception zu aufrufender Methode weiterleiten

TestMethode mit finally try { int i = int.Parse(s); Console.WriteLine("Division: 2/{0}={1}", i, 2 / i); } finally Console.Write("\nDie Eingabe war: {0}\n", s);

TestKlasse benutzen static void Main(String[] args) { TestKlasse t = new TestKlasse(); String s=""; while(!s.Equals("e")) Console.Write("Bitte ganze Zahl eingeben oder 'e' zum Beenden: "); s = Console.ReadLine(); try t.TestMethode(s); } catch (DivideByZeroException e) { Console.WriteLine(e.Message); } catch (FormatException e) Erst nachdem der finally Block ausgeführt wurde, wird die Exception im passenden catch-Block behandelt.

Nach dem Handbuch der .NET 4.0-Programmierung, Rolf Wenger, 2012 Der Ablauf static void Main(String[] args) { TestKlasse t = new TestKlasse(); String s=""; while(!s.Equals("e")) Console.Write("Bitte ganze Zahl eingeben oder 'e' zum Beenden: "); s = Console.ReadLine(); try t.TestMethode(s); } catch (DivideByZeroException e) { Console.WriteLine(e.Message); } catch (FormatException e) public class TestKlasse { public void TestMethode(String s) try int i = int.Parse(s); Console.WriteLine("Division: 2/{0}={1}", i, 2 / i); } finally Console.Write("\nDie Eingabe war: {0}\n", s); Im Fehlerfall immer Sonst Nach dem Handbuch der .NET 4.0-Programmierung, Rolf Wenger, 2012