Von VBA zu C#: Fehlerbehandlung

Lies diesen Artikel und viele weitere mit einem kostenlosen, einwöchigen Testzugang.

Nur wenige Access-Programmierer statten ihre Anwendungen mit einer ordentlichen Fehlerbehandlung aus. Für viele ist dies ein leidiges Thema. Die Fehlerbehandlung sorgt im Optimalfall sowohl unter VBA als auch unter C# dafür, dass eine Anwendung stabiler wird und nach dem Auftreten von Laufzeitfehlern nicht unerwartet reagiert oder sogar abstürzt. Während es unter VBA nur wenige Konstrukte gibt, um eine Fehlerbehandlung zu implementieren, bietet C# schon eine Menge mehr. Dieser Artikel liefert eine Einführung und zeigt, wie Sie die von VBA gewohnten Techniken unter C# einsetzen.

Die minimale Fehlerbehandlung unter VBA sieht so aus, dass Sie vor fehlerträchtigen Anweisungen die eingebaute Fehlerbehandlung mit der folgenden Programmzeile deaktivieren:

On Error Resume Next

Alle folgenden Fehler in der aktuellen Routine und in solchen, die von dieser Routine aufgerufen werden, werden nicht behandelt. Dadurch gibt es zwar immerhin keine Fehlermeldung und es werden keine Variablen geleert, was beim Auftreten unbehandelter Fehler auftreten kann. Allerdings erledigen fehlerhafte Zeilen ihre Aufgabe nicht, was zu Folgefehlern (auch logischen Fehlern) in den folgenden Anweisungen führen kann.

Spätestens mit dem Ende der Routine endet die Deaktivierung der eingebauten Fehlerbehandlung. Vorher erhalten Sie dies mit der folgenden Anweisung:

On Error Goto 0

Dadurch reagiert VBA wieder wie gewohnt mit entsprechenden Fehlermeldungen auf Fehler.

Dazwischen haben Sie Gelegenheit, benutzerdefiniert auf die auftretenden Fehler zu reagieren – beispielsweise, indem Sie den Wert der Eigenschaft Number des Err-Objekts auslesen und für die interessanten Werte entsprechende Fehlerbehandlungen hinzufügen.

Dies kann beispielsweise wie folgt aussehen:

On Error Resume Next
Debug.Print 1/0
Select Case Err.Number
     Case 11
         MsgBox "Fehler: Teilen durch 0."
End Select
On Error Goto 0

Unter C# gibt es zur Fehlerbehandlung andere Möglichkeiten, die Sie in den folgenden Abschnitten kennen lernen.

Warum überhaupt eine Fehlerbehandlung

Um auf Nummer sicher zu gehen, wollen wir zuvor noch einmal kurz auf die Gründe für die Programmierung einer benutzerdefinierten Fehlerbehandlung eingehen. Wenn Sie Code programmieren, der fehlerhafte Eingaben zulässt und keine entsprechende benutzerdefinierte Fehlerbehandlung aufweist, erhalten Sie beispielsweise bei einer Konsolenanwendung eine Meldung plus Fehlerbehandlungsfenster wie in Bild 1.

Unbehandelte Ausnahme bei einer Konsolenanwendung

Bild 1: Unbehandelte Ausnahme bei einer Konsolenanwendung

Wenn Sie einen solchen Fehler in einer WPF-Anwendung auslösen, erhalten Sie noch nicht einmal einen kleinen Hinweis auf den Fehler im Code, der zu dieser Ausnahme führte (siehe Bild 2).

Unbehandelte Ausnahme bei einer Windows-Anwendung

Bild 2: Unbehandelte Ausnahme bei einer Windows-Anwendung

Noch übler wird es, wenn nicht Sie selbst die Software bedienen, sondern ein Kunde: Erstens macht dies nie einen guten Eindruck, zweitens kann der Kunde auf Basis der hier gelieferten Fehlerinformationen kaum helfen, den Fehler zu finden.

Also sollten Sie dafür sorgen, dass der Kunde einen aussagekräftigen Text als Fehlermeldung erhält, der ihn beispielsweise bei einem Eingabefehler auf die Ursache des Fehlers hinweist oder aber ihm die Informationen liefert, die er zur Behebung des Problems an den Entwickler der Software weitergeben kann.

Der wichtigste Punkt beim Implementieren einer benutzerdefinierten Fehlerbehandlung etwa unter VBA ist jedoch die stabile Fortsetzung der Anwendung: Wenn ein Fehler aufgetreten ist, beispielsweise durch eine Fehleingabe oder einen fehlerhaften Zugriff auf ein Element, dann sollte die Anwendung nach der Ausgabe der Fehlermeldung fortgesetzt werden können und nicht einfach abbrechen. Dabei ist außerdem sicherzustellen, dass die Funktion und der stabile Zustand der Anwendung durch den Fehler nicht beeinträchtigt werden. Bei VBA war das mitunter ganz einfach deshalb nicht der Fall, weil durch unbehandelte Fehler Variableninhalte gelöscht oder Objekte zerstört wurden. Wurden die Zeilen, die den Fehler auslösten, hingegen per On Error Resume Next einer benutzerdefinierten Fehlerbehandlung zugeführt, statt einfach unbehandelte Fehler auszulösen, war zumindest schon einmal der Inhalt und der Zustand der Variablen sichergestellt.

Fehlerhafter Code

Schauen wir uns das Beispiel an, das zum Auslösen der Ausnahme der Konsolenanwendung führte. Den Code finden Sie in Listing 1. Die Zeile, die das Ergebnis der Division der Werte der Variablen Dividend und Divisor ermitteln soll, löst die Ausnahme aus, wenn der Divisor zuvor den Wert 0 zugewiesen bekommen hat – der Fehler tritt also durch eine Division durch 0 auf.

static void Main(string[] args) {
     Console.WriteLine("Geben Sie den Dividend und den Divisor als ganze Zahlen ein.");
     Console.WriteLine("Dividend:");
     decimal Dividend = Convert.ToDecimal(Console.ReadLine());
     Console.WriteLine("Divisor:");
     decimal Divisor = Convert.ToDecimal (Console.ReadLine());
     decimal Quotient = Dividend / Divisor;
     Console.WriteLine("Der Quotient lautet: {0}", Quotient);
     Console.ReadLine();
}

Listing 1: Methode, die einen Fehler auslöst, wenn als Divisor der Wert 0 angegeben wird

Wenn Sie die Anwendung debuggen, also diese von Visual Studio aus etwa mit der Taste F5 starten, erhalten Sie einige Fehlerinformationen mehr. Außerdem markiert Visual Studio gleich die fehlerhafte Zeile (siehe Bild 3). Es gibt sogar noch Tipps zur Problembehandlung.

Auslösen einer Ausnahme unter C#

Bild 3: Auslösen einer Ausnahme unter C#

Wenn Sie möchten, erhalten Sie auch noch weitere Details, und zwar durch einen Mausklick auf den Link Details anzeigen …, der den Dialog aus Bild 4 öffnet.

Details zu einer Ausnahme beim Debuggen in Visual Studio

Bild 4: Details zu einer Ausnahme beim Debuggen in Visual Studio

Für Fehler wie diese gibt es einige Beispiele – die Eingabe unzulässiger Werte wie in diesem Beispiel, Zugriff auf nicht vorhandene Dateien et cetera.

try…catch statt On Error Resume Next

Unter C# können Sie Laufzeitfehler in sogenannten try…catch-Blöcken behandeln. Das sieht dann so aus, dass Sie den Code, der einen Fehler auslösen könnte, in den try-Block packen und den Code, der ausgelöst werden soll, wenn innerhalb des try-Blocks ein Fehler auftritt, in den catch-Block.

In unserem Fall wollen wir die Zeile, welche die Division durchführt, in den try-Block überführen. Gleichzeitig fügen wir dort auch die Zeile ein, welche das Ergebnis aus der Variablen Quotient in der Konsole ausgibt – sonst ergibt dies einen Syntaxfehler, weil Quotient nicht in jedem Falle deklariert und initialisiert wird.

In den catch-Block schreiben wir eine Anweisung, welche einen Hinweis auf das Auftreten eines Fehlers in der Konsole ausgibt (siehe Listing 2). Wie Sie hier erkennen, wird die folgende Anweisung, die ja das Ergebnis der Berechnung ausgeben sollte, ignoriert – dies gilt grundsätzlich für alle Anweisungen, die der fehlerhaften Anweisung folgen.

try {
     decimal Quotient = Dividend / Divisor;
     Console.WriteLine("Der Quotient lautet: {0}", Quotient);
}
catch {
     Console.WriteLine("Ups! Es ist ein Fehler beim Rechnen aufgetreten!");
}

Listing 2: Abfangen eines Fehlers per try…catch-Block

Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...

Testzugang

eine Woche kostenlosen Zugriff auf diesen und mehr als 1.000 weitere Artikel

diesen und alle anderen Artikel mit dem Jahresabo

Schreibe einen Kommentar