Was wäre eine Anwendung ohne Fehlerbehandlung Auch wenn wir in den bisherigen Beispielanwendungen meist gar keine Fehlerbehandlung genutzt haben, weil der Code so übersichtlicher ist. Wenn Sie aber eine Anwendung an Kunden weitergeben, sollte diese keine unbehandelten Ausnahmen liefern. Deshalb beschreiben wir im vorliegenden Artikel, wie die Fehlerbehandlung unter VB.NET funktioniert und welche Unterschiede sich zur Fehlerbehandlung unter Access\/VBA ergeben.<\/b><\/p>\n
Beispiele ausprobieren<\/b><\/p>\n
Wir haben die Beispiele im Tool LINQPad eingegeben und ausprobiert. Das Tool ist in der Basisversion kostenlos und erlaubt das Ausführen von VB.NET-Prozeduren, ohne das Sie immer erst ein Projekt zum Debuggen starten müssen. Den Download des Tools finden Sie unter www.linqpad.net<\/b>.<\/p>\n
Von VBA zu VB.NET<\/b><\/p>\n
Unter VBA war die Fehlerbehandlung recht einfach: Wir haben mit On Error Resume Next <\/b>festgelegt, dass die Fehlerbehandlung für die folgenden Zeilen ausgesetzt wird und haben selbst mit Err.Number <\/b>geprüft, ob ein Fehler aufgetreten ist und entsprechend darauf reagiert. Damit haben wir dann gezielt Fehler behandelt. Oder man hat zu Beginn einer Prozedur mit einer Anweisung wie On Error Goto Fehler <\/b>festgelegt, dass die Prozedur im Falle eines Fehlers zu einer Marke namens Fehler <\/b>springen sollte, wo wir dann eine allgemeine Fehlerbehandlung eingebaut haben, die beispielsweise eine E-Mail mit der Fehlermeldung und weiteren Informationen an den Hersteller der Software geschickt hat.<\/p>\n
Wenn Sie eine Anwendung von Access nach VB.NET migrieren und dabei möglichst viel Quellcode übernehmen wollen, gibt es allerdings eine gute Nachricht: Die unter VBA verwendeten Befehle für die Fehlerbehandlung funktionieren auch noch unter VB.NET.<\/p>\n
Das folgende klassische Beispiel liefert allerdings nicht den Beweis, dass die Fehlerbehandlung wie unter VBA funktioniert. Dafür benötigen Sie allerdings einen Verweis auf den Namespace Microsoft.VisualBasic<\/b>:<\/p>\n Das Ergebnis der Division von 1 <\/b>und 0 <\/b>wird nämlich einfach wie folgt ausgegeben:<\/p>\n 8<\/p>\n Also lösen wir den Fehler mit der entsprechenden .NET-Anweisung aus, nämlich ThrowException<\/b>:<\/p>\n Damit haben wir auch gleich die erste Anweisung der Ausnahmebehandlung unter VB.NET kennengelernt – die Thow-Anweisung dient dazu, Ausnahmen auszulösen. Mehr dazu weiter unten! Übrigens sollten Sie, auch wenn es möglich ist, nicht mehr die von VBA gewohnten Möglichkeiten zur Fehlerbehandlung nutzen.<\/p>\n Fehlerbehandlung unter VB.NET<\/b><\/p>\n .NET bietet wesentlich umfassendere Möglichkeiten für die Fehlerbehandlung oder, wie man hier sagt, Ausnahmebehandlung. Die grobe Richtschnur für eine Fehlerbehandlung unter VB.NET ist ein Block ähnlich einer If…Then…Else<\/b>-Bedingung mit den drei Anweisungen Try<\/b>, Catch <\/b>und Finally<\/b>. Die Mindestanforderung sind die beiden Anweisungen Try<\/b>, Catch <\/b>und die End Try<\/b>-Anweisung:<\/p>\n Das Pendant zu der Fehlerbehandlung von oben mit der Division durch 0 würde also wie folgt aussehen:<\/p>\n Der Aufbau ist also prinzipiell gar nicht so viel anders als unter VBA. Der Teil zwischen Catch… <\/b>und End Try <\/b>wird nur ausgeführt, wenn eine Ausnahme ausgelöst wird. Ein wichtiger Unterschied: Es gibt unter VB.NET kein Err<\/b>-Objekt (zumindest nicht, wenn Sie Try…Catch <\/b>verwenden). Dafür legen Sie in der Catch<\/b>-Anweisung jedoch ein Objekt des Typs Exception <\/b>fest, hier mit der Bezeichnung ex<\/b>. Exception<\/b> liefert uns wie Err <\/b>zwar eine Meldung, aber keine Fehlernummer.<\/p>\n Wie sollen wir das nun vernünftig auswerten und je nach Fehler entsprechend reagieren<\/p>\n Ganz einfach: Es gibt für jede Ausnahme eine spezielle Exception. Für diesen Fall ist diese leicht zu finden, denn die Exception wird durch das “Werfen” der Ausnahme DivideByZeroException <\/b>ausgelöst. Dementsprechend können wir die Catch<\/b>-Anweisung direkt etwas genauer definieren, sodass diese nur auf DivideByZeroException<\/b>-Ausnahmen reagiert:<\/p>\n Da Sie wissen, welcher Fehler hier behandelt wird, können Sie die Meldung auch anpassen, ohne auf ex.Message <\/b>zuzugreifen:<\/p>\n Tritt nach der Try<\/b>-Anweisung eine andere Ausnahme als DivideByZeroException <\/b>auf, führt dies allerdings zu einer unbehandelten Ausnahme – zum Beispiel wenn Sie mit folgender Anweisung einen Dateifehler auslösen:<\/p>\n Wir sollten also auch mit der allgemeinen Ausnahme Exception <\/b>alle möglichen Ausnahmen abfangen. Dazu fügen wir einfach einen weiteren Catch<\/b>-Zweig zu dem Konstrukt hinzu:<\/p>\n Restarbeiten mit und ohne Ausnahme<\/b><\/p>\n Unter VBA haben wir für Restarbeiten, die in jedem Fall, also auch beim Auftreten eines Fehlers zu erledigen sind, wie folgt untergebracht:<\/p>\n Wir haben also unter der Marke Ende <\/b>Befehle untergebracht, die auch beim Ausbleiben eines Fehlers ausgelöst werden. Damit die Fehler<\/b>-Marke nur erreicht wird, wenn tatsächlich ein Fehler auftritt, haben wir dieser die Exit Sub<\/b>– beziehungsweise Exit Function<\/b>-Anweisung vorangestellt. Damit die Aufräumarbeiten aber auch nach Auftreten eines Fehlers noch ausgeführt werden, haben wir am Ende der Fehlerbehandlung noch einen Verweis zur Marke Ende <\/b>hinzugefügt.<\/p>\n Unter VB.NET benötigen wir dazu nur einen weiteren Zweig im Try…End Try<\/b>-Konstukt. Dieser Zweig heißt Finally <\/b>und wird immer am Ende eingebaut:<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>Sub <\/span>DivisionByZero\r\n On Error Resume Next<\/span>\r\n Debug.Print<\/span>(1 \/ 0)\r\n If <\/span>Not<\/span> (Err.Number = 0) Then<\/span>\r\n Debug.Print<\/span>(\"Fehler: \" + Err.Number + \" \" + Err.Description)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nOn Error Resume Next<\/span>\r\nThrow New<\/span> DivideByZeroException()\r\n'Debug.Print<\/span>(1 \/ 0)\r\nIf <\/span>Not<\/span> (Err.Number = 0) Then<\/span>\r\n Debug.Print<\/span>(\"Fehler: \" & Err.Number & \" \" & Err.Description)\r\nEnd If<\/span><\/pre>\nTry\r\n 'auszuführender Code, der eine Ausnahme auslösen könnte\r\nCatch ex As <\/span>Exception\r\n 'Code, der beim Auftreten der Ausnahme ausgeführt werden soll\r\nEnd Try<\/pre>\nSub <\/span>DivisionByZeroVBNET\r\n Try\r\n Throw New<\/span> DivideByZeroException()\r\n Catch ex As <\/span>Exception \r\n Debug.Print<\/span>(\"Fehler: \" & ex.Message)\r\n End Try\r\nEnd Sub<\/span><\/pre>\nSub <\/span>DivisionByZeroVBNET_DivideByZeroException\r\n Try\r\n Throw New<\/span> DivideByZeroException()\r\n Catch ex As <\/span>DivideByZeroException\r\n Debug.Print<\/span>(\"Fehler: \" & ex.Message & \" \")\r\n End Try\r\nEnd Sub<\/span><\/pre>\nDebug.Print<\/span> (\"Division durch Null.\")<\/pre>\nThrow New<\/span> FileNotFoundException<\/pre>\nTry\r\n Throw New<\/span> FileNotFoundException\r\n Throw New<\/span> DivideByZeroException()\r\nCatch ex As <\/span>DivideByZeroException\r\n Debug.Print<\/span>(\"Die Datei konnte nicht gefunden werden.\")\r\nCatch ex As <\/span>Exception\r\n Debug.Print<\/span>(\"Fehler: \" & ex.Message)\r\nEnd Try<\/pre>\n On Error Resume Fehler\r\n 'Fehlerauslösende Zeile\r\nEnde:\r\n 'Restarbeiten\r\n Exit Sub<\/span>\r\nFehler:\r\n 'Fehlerbehandlung\r\n Goto Ende<\/pre>\nSub <\/span>TryCatchFinally\r\n Try\r\n Throw New<\/span> FileNotFoundException\r\n Throw New<\/span> DivideByZeroException()\r\n Catch ex As <\/span>DivideByZeroException\r\n Debug.Print<\/span>(\"Fehler: \" & ex.Message)\r\n Catch ex As <\/span>Exception\r\n Debug.Print<\/span>(\"Fehler: \" & ex.Message)\r\n Finally\r\n Debug.Print<\/span>(\"Restarbeiten\")\r\n End Try\r\nEnd Sub<\/span><\/pre>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t