Eine Fehlerbehandlung ist Teil einer professionellen Datenbankanwendung auf Basis von Microsoft Access. Sobald wir eine Datenbank an einen Kunden oder Mitarbeiter weitergeben, also an einen anderen Benutzer als uns selbst, ist dies praktisch ein Pflichtprogramm. Die Fehlerbehandlung soll den Benutzer über einen Fehler informieren und diesem die Möglichkeit geben, dem Entwickler Informationen über den Fehler zukommen zu lassen. In diesem Beitrag wollen wir die Hauptarbeit bei der Implementierung einer Fehlerbehandlung erledigen. Dazu wollen wir eine Prozedur schreiben, die beliebige Routinen, also Sub-, Function- und Property-Prozeduren, mit einer einfachen Fehlerbehandlung ausstattet – und überdies noch mit einer Zeilennummerierung. Diese ist wichtig, wenn wir schnell herausfinden wollen, an welcher Stelle ein Fehler aufgetreten ist. Zusammen mit dem Namen des Moduls, dem Namen der Prozedur, der Fehlernummer und der Fehlerbeschreibung erhalten wir so Informationen, die in der Regel zum Aufdecken des Fehlers führen.<\/b><\/p>\n
Wir wollen in diesem Beitrag eine minimale Fehlerbehandlung verwenden, die nur die nötigsten Informationen aufnimmt. Dazu gehören die folgenden:<\/p>\n
Woher bekommen wir diese Informationen?<\/p>\n
Die Fehlernummer und die Fehlerbeschreibung erhalten wir per VBA grundsätzlich nur, wenn wir die eingebaute Fehlerbehandlung von VBA ausgeschaltet haben. Das erledigen wir mit einer der folgenden Anweisungen:<\/p>\n
On Error Resume Next<\/span>\r\nOn Error GoTo<\/span> Sprungmarke<\/pre>\nDabei ist Sprungmarke eine Zeile, die den Namen der Sprungmarke und einen Doppelpunkt enthält, zum Beispiel:<\/p>\n
Errorhandling:<\/pre>\nWenn wir die eingebaute Fehlerbehandlung wieder einschalten wollen, können wir dies mit der folgenden Anweisung erledigen:<\/p>\n
On Error GoTo<\/span> 0<\/pre>\nWährend die eingebaute Fehlerbehandlung ausgeschaltet ist, werden Fehler entweder einfach ignoriert (On Error Resume Next<\/b>) oder der Code wird an der angegebenen Sprungmarke fortgesetzt, wenn eine angegeben wurde (On Error Goto Errorhandler<\/b>).<\/p>\nFehlernummer und Fehlerbeschreibung ermitteln<\/h2>\n
In jedem Fall können wir in den darauffolgenden Zeilen die Eigenschaften des Err<\/b>-Objekts auslesen. Das können wir zwar immer, aber wenn kein unbehandelter Fehler aufgetreten ist, liefert dies auch keine Fehlerinformationen.<\/p>\n
Gehen wir jedoch davon aus, dass wir die Informationen nach Auftreten eines Fehlers abfragen, können wir dem Err<\/b>-Objekt die folgenden Informationen entnehmen:<\/p>\n\n- Err.Number<\/b>: Liefert die Fehlernummer, zum Beispiel 11<\/b>.<\/li>\n
- Err.Description<\/b>: Liefert die Fehlerbeschreibung, zum Beispiel Division durch Null<\/b>.<\/li>\n<\/ul>\n
Name des VBA-Projekts ermitteln<\/h2>\n
Wir könnten mit der Err<\/b>-Eigenschaft Err.Source <\/b>sogar noch den Namen des VBA-Projekts ermitteln, in dem der Fehler ausgelöst wurde. Dies ist jedoch nicht unbedingt notwendig, da sich die Fehlerbehandlung meist auf das gleiche VBA-Projekt bezieht, in dem sich diese befindet.<\/p>\nZeilennummer ermitteln<\/h2>\n
Die Nummer der Zeile, in welcher der Fehler aufgetreten ist, finden wir offiziell gar nicht. Allerdings gibt es eine nicht dokumentierte Funktion namens Erl<\/b>, die uns im Falle eines Fehlers die Nummer der Zeile mit der auslösenden Anweisung liefert. Dies geschieht jedoch nur, wenn es auch eine Zeilennummerierung gibt. Diese müssen wir selbst hinzufügen, es gibt keine eingebaute Funktion, um dies einfach zu erledigen.<\/p>\n
Wie wir die Zeilennummer hinzufügen, haben wir deshalb ausführlich beschrieben, und zwar im Beitrag Zeilennummern per VBA hinzufügen <\/b>(www.access-im-unternehmen.de\/1515<\/b>). Hier finden Sie sogar Prozeduren, mit denen Sie die Zeilennummern für eine Prozedur, alle Prozeduren eines Moduls und sogar für alle Module in einem VBA-Projekt per Mausklick anlegen können.<\/p>\nProzedurname und Modulname ermitteln<\/h2>\n
Den Prozedurnamen und den Modulnamen können wir ebenfalls nicht automatisch ermitteln. Es ist jedoch dennoch sinnvoll, diesen in einer Fehlerbehandlung auszugeben – dabei spielt es keine Rolle, ob die Fehlerbehandlung nur eine Meldung anzeigt, die Fehlerinformationen in eine Tabelle schreibt oder direkt eine E-Mail an den Entwickler der Anwendung schickt.<\/p>\n
In jedem Fall werden wir in einer Fehlerbehandlung landen, die sich innerhalb der Prozedur befindet, in welcher der Fehler ausgelöst wurde. Diese befindet sich in der Regel hinter einer Sprungmarke am Ende der jeweiligen Prozedur. Und wenn wir ohnehin für jede Prozedur eine eigene Fehlerbehandlung hinzufügen müssen, dann können wir hier auch direkt die Information unterbringen, in welchem Modul und in welcher Prozedur wir uns gerade befinden.<\/p>\n
Das gilt auch, wenn sich die Fehlerbehandlungsanweisungen nicht selbst in der Prozedur befinden, sondern in einer eigenen Routine. Dann müssen wir dafür sorgen, dass der Modul- und der Prozedurname zur dortigen Routine gelangen und können diese im Aufruf der fehlerauslösenden Prozedur platzieren.<\/p>\n
Das sieht beispielsweise wie folgt aus:<\/p>\n
Public Sub <\/span>Test_WriteError()\r\n10 On Error GoTo<\/span> Errorhandling\r\n20 Debug.Print<\/span> 1 \/ 0\r\n30 Exit Sub<\/span>\r\nErrorhandling:\r\n HandleError Err.Number, Err.Description, Erl, _\r\n \"Test_WriteError\", \"mdlErrors\"\r\nEnd Sub<\/span><\/pre>\nDie Prozedur hat bereits Zeilennummern und die eingebaute Fehlerbehandlung wird mit On Error Goto Errorhandling <\/b>deaktiviert. Der Fehler durch die Division durch 0 <\/b>in Zeile 20 <\/b>führt somit dazu, dass die Prozedur direkt zur Sprungmarke Errorhandling <\/b>springt. Hier rufen wir eine Prozedur namens HandleError <\/b>auf, die unsere Fehlerbehandlungsroutine enthält. Dieser übergeben wir alle Daten, die wir in der Fehlerbehandlungsroutine verarbeiten wollen – die Fehlernummer, die Fehlerbeschreibung, die Zeilennummer, den Modulnamen und den Prozedurnamen. An dieser Stelle wird klar: Wenn wir diese Fehlerbehandlung zu vielen Prozeduren hinzufügen wollen, können wir zwar mit Copy und Paste arbeiten, aber wir müssen dennoch viele Anpassungen vornehmen. In diesem Fall müssen wir jeweils den Modulnamen und den Prozedurnamen anpassen. Beim Modulnamen muss man dies nur einmal pro Modul erledigen und kann die entsprechenden Zeilen dann kopieren und braucht nur noch den Prozedurnamen anzupassen. Viel Aufwand bleibt es dennoch, und es ist auch nicht wenig fehleranfällig.<\/p>\nFehlerbehandlungsroutine<\/h2>\n
Die Routine namens HandleError<\/b>, die wir von allen Prozeduren mit einer Fehlerbehandlung aus aufrufen wollen, finden Sie in Listing 1. In diesem Fall wollen wir aufgetretene Fehler einfach in eine Tabellenamens tblErrors <\/b>schreiben, die sich in der gleichen Datenbank befindet. Diese enthält Felder für alle erwähnten Fehlerinformationen und zuzüglich noch ein Feld mit Datum und Uhrzeit.<\/p>\nPublic Sub <\/span>HandleError(lngNumber As Long<\/span>, strMessage As String<\/span>, lngLine As Long<\/span>, strProcedure As String<\/span>, _\r\n strModule As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"INSERT INTO tblErrors(ErrorNumber, ErrorMessage, ErrorLine, ErrorProcedure, ErrorModule) VALUES(\" _\r\n & lngNumber & \", ''\" & Replace<\/span>(strMessage, \"''\", \"''''\") & \"'', \" & lngLine & \", ''\" & strProcedure & \"'', ''\" _\r\n & strModule & \"'')\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\nListing 1: Fehlerbehandlungsroutine<\/span><\/b><\/p>\nFür dieses legen wir als Standardwert Jetzt() <\/b>fest, damit wir dieses Feld nicht per Code füllen müssen (siehe Bild 1).<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2024_05\/pic_1514_001.png\")
<\/p>\n
Bild 1: Tabelle zum Speichern der Fehlerinformationen<\/span><\/b><\/p>\nDie Fehlerbehandlungsroutine enthält im Wesentlichen eine INSERT INTO<\/b>-Anweisung, die einen neuen Datensatz in die Tabelle tblErrors <\/b>schreibt und die mit der Execute<\/b>-Methode des Database<\/b>-Objekts ausgeführt wird.<\/p>\n
Wenn wir unsere Fehlerbehandlung einige Male mit der obigen Beispielprozedur auslösen, finden wir Einträge wie in Bild 2 in der Tabelle tblErrors <\/b>vor.<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2024_05\/pic_1514_002.png\")
<\/p>\n
Bild 2: Tabelle zum Speichern der Fehlerinformationen mit einige Fehlern<\/span><\/b><\/p>\nAlternativen zum Eintrag in die Fehlertabelle<\/h2>\n
Wenn Sie in Ihrer Anwendung einmal alle Prozeduren, bei denen es sinnvoll ist (in der Regel alle), mit einer Fehlerbehandlung ausgestattet haben, können Sie die im Falle eines Fehlers durchzuführenden Aktionen einfach ändern. Dazu brauchen Sie nur die Anweisungen in der Prozedur HandleError<\/b> anzupassen. Der Fantasie sind hier keine Grenzen gesetzt – Sie können die Daten wir hier in eine Tabelle schreiben, eine E-Mail mit Fehlerinformationen an den Entwickler senden, einfach nur eine Fehlermeldung anzeigen oder auch Fehlermeldungen in eine Textdatei außerhalb der Datenbankdatei schreiben.<\/p>\n
Sie können auch verschiedene dieser Vorschläge kombinieren. In der Regel ist es immer von Vorteil, wenn man den Benutzer über einen Fehler informiert, damit dieser gegebenenfalls weitere Schritte durchführen kann – wie den Entwickler zu informieren.<\/p>\n
Fehlerbehandlung anwendungsweit integrieren<\/h2>\n
Nun stehen wir nur noch vor einer Fleißaufgabe. Wir müssen die Zeilen, die für die Funktion der Fehlerbehandlung nötig sind, in jede Prozedur eintragen. <\/p>\n
Das sind aus der Beispielprozedur von oben alle Anweisungen außer Prozedurkopf, -fuß und der eigentlichen Anweisung:<\/p>\n
Public Sub <\/span>Test_WriteError()\r\n10 On Error GoTo<\/span> Errorhandling\r\n20 Debug.Print<\/span> 1 \/ 0\r\n30 Exit Sub<\/span>\r\nErrorhandling:\r\n HandleError Err.Number, Err.Description, Erl, _\r\n \"Test_WriteError\", \"mdlErrors\"\r\nEnd Sub<\/span><\/pre>\nUnd wenn wir, wie im Beitrag Zeilennummern per VBA hinzufügen <\/b>(www.access-im-unternehmen.de\/1515<\/b>) beschrieben, auch Zeilennummern automatisiert zu Prozeduren hinzufügen können, warum sollten wir dann nicht automatisch die immer wiederkehrenden Zeilen hinzufügen?<\/p>\nProzedur zum automatisierten Hinzufügen einer Fehlerbehandlung<\/h2>\n
Hier verwenden wir die Prozedur AddErrorHandler<\/b> aus Listing 2. Sie erwartet die folgenden Parameter:<\/p>\nPublic Sub <\/span>AddErrorHandler(strModule As String<\/span>, strProcedure As String<\/span>)\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodemodule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>lngCountOfLines As Long<\/span>\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n Dim <\/span>lngProcBodyLine As Long<\/span>\r\n Dim <\/span>strProcBodyLine As String<\/span>\r\n Dim <\/span>lngFirstStatementLineNumber As Long<\/span>\r\n Dim <\/span>lngLastStatementLineNumber As Long<\/span>\r\n Dim <\/span>strProcType As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodemodule = objVBComponent.CodeModule\r\n lngCountOfLines = objCodemodule.CountOfLines\r\n lngProcBodyLine = objCodemodule.ProcBodyLine(strProcedure, intProcType)\r\n lngFirstStatementLineNumber = GetFirstStatementLineNumber(objCodemodule, lngProcBodyLine)\r\n lngLastStatementLineNumber = GetLastStatementLineNumber(objCodemodule, lngFirstStatementLineNumber)\r\n strProcBodyLine = GetProcBodyLine(objCodemodule, lngProcBodyLine)\r\n strProcType = GetProcType(strProcedure, strProcBodyLine)\r\n objCodemodule.InsertLines lngFirstStatementLineNumber, \" On Error GoTo<\/span> Errorhandling\"\r\n objCodemodule.InsertLines lngLastStatementLineNumber + 2, \" Call<\/span> HandleError(Err.Number, Err.Description, _\r\n Erl, \"\"\" & strProcedure & \"\"\", \"\"\" & strModule & \"\"\")\"\r\n objCodemodule.InsertLines lngLastStatementLineNumber + 2, \"Errorhandling:\"\r\n objCodemodule.InsertLines lngLastStatementLineNumber + 2, \" Exit \" & strProcType\r\nEnd Sub<\/span><\/pre>\nListing 2: Prozedur zum Hinzufügen einer Fehlerbehandlung zu einer Prozedur<\/span><\/b><\/p>\n\n- strModule<\/b>: Name des Moduls<\/li>\n
- strProcedure<\/b>: Name der Prozedur, in der die Fehlerbehandlung hinzugefügt werden soll<\/li>\n<\/ul>\n
Die Prozedur füllt die Variable objVBProject <\/b>mit einem Verweis auf das aktuelle VBA-Projekt. Dann ermittelt sie das VBComponent<\/b>-Objekt zu dem mit strModule <\/b>angegebenen Modul und referenziert es mit der Variablen objVBComponent<\/b>. Über ihre Eigenschaft CodeModule <\/b>holt sie sich einen Verweis auf das CodeModule<\/b>-Objekt des Moduls.<\/p>\n
Nun ermittelt sie einige Zeilennummern:<\/p>\n
\n- lngCountOfLines<\/b>: Wird mit der Anzahl der Zeilen des Moduls gefüllt.<\/li>\n
- lngProcBodyLine<\/b>: Wird mit der Nummer der ersten Zeile der Prozedur aus strProcedure <\/b>gefüllt. Für den Pflichtparameter ProcKind <\/b>übergeben wir die leere Variable intProcType<\/b>. Diese erhält einen Wert für den Typ der Prozedur, den wir aber nicht benötigen.<\/li>\n
- lngFirstStatementLineNumber<\/b>: Hier ermitteln wir mit der Funktion GetFirstStatementLineNumber <\/b>die Nummer der Zeile mit der ersten Anweisung der Prozedur, also die erste Zeile hinter der gegebenenfalls auch aus mehreren Zeilen bestehenden Kopfzeile. Diese Funktion beschreiben wir im Detail im Beitrag Zeilennummern per VBA hinzufügen <\/b>(www.access-im-unternehmen.de\/1515<\/b>).<\/li>\n
- strProcBodyLine<\/b>: Wird über die Funktion GetProcBodyLine<\/b>, die wir ebenfalls im oben genannten Beitrag beschreiben, mit der kompletten Kopfzeile der Prozedur ohne Zeilenumbrüche gefüllt. Dieser übergeben wir einen Verweis auf das CodeModule<\/b>-Objekt und die erste Zeile der Prozedur.<\/li>\n
- strProcType<\/b>: Hier ermitteln wir mit der Funktion GetProcType<\/b>, die wir ebenfalls im oben genannten Beitrag beschreiben, den Typ der Prozedur, und zwar Sub<\/b>, Function<\/b> oder Property<\/b>.<\/li>\n
- lngLastStatementLineNumber<\/b>: Erhält die mit der Funktion GetLastStatementLineNumber <\/b>ermittelte Nummer der letzten Zeile vor der Zeile mit der End …<\/b>-Anweisung.<\/li>\n<\/ul>\n
Danach beginnt die eigentliche Aktion: Die erste InsertLines<\/b>-Methode fügt die Zeile On Error Goto Errorhandling <\/b>an Stelle der mit lngFirstStatementLineNumber <\/b>angegebenen ersten Zeile der Prozedur ein. Die nächste Anweisung beginnt mit dem Einfügen der Zeilen am Ende der Prozedur. Damit wir nur die Nummer der Zeile der letzten Anweisung benötigen, fügen wir die Anweisungen in umgekehrter Reihenfolge ein. Wir starten also mit der letzten Zeile, die den Aufruf der Fehlerbehandlungsroutine enthält. Damit wird die Fußzeile um eine Zeile nach unten verdrängt.<\/p>\n
Danach fügen wir die Zeile mit der Sprungmarke ein, was wiederum die beiden letzten Zeilen nach hinten verschiebt.<\/p>\n
Schließlich folgt noch die Anweisung Exit Sub<\/b>\/Exit Function<\/b>\/Exit Property<\/b>, damit die Prozedur bei regulären Verlauf vor Erreichen der Fehlerbehandlung verlassen wird.<\/p>\n
Auf diese Weise können wir einer Prozedur in einem Modul die gewünschte Fehlerbehandlung hinzufügen.<\/p>\n
Fehlerbehandlungen zu allen Prozeduren eines Moduls hinzufügen<\/h2>\n
Mit der Prozedur AddErrorHandlersToModule<\/b>, die den Namen des Moduls als Parameter erwartet, rufen wir die Prozedur AddErrorHandler <\/b>für jede Prozedur des angegebenen Moduls auf (siehe Listing 3).<\/p>\nPublic Sub <\/span>AddErrorHandlersToModule(strModule As String<\/span>)\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodemodule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n Dim <\/span>lngCountOfLines As Long<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>strProcedure As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodemodule = objVBComponent.CodeModule\r\n lngCountOfLines = objCodemodule.CountOfLines\r\n For lngLine = 1 To lngCountOfLines\r\n If <\/span>Not<\/span> strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType) Then<\/span>\r\n strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType)\r\n Call<\/span> AddErrorHandler(strModule, strProcedure)\r\n End If<\/span>\r\n Next<\/span> lngLine\r\nEnd Sub<\/span><\/pre>\nListing 3: Prozedur zum Hinzufügen von Fehlerbehandlungen zu allen Prozeduren eines Moduls<\/span><\/b><\/p>\nDie Prozedur ermittelt Verweise auf das aktuelle VBA-Projekt und das betroffenen CodeModule<\/b>-Objekt und ermittelt für die Variable lngCountOfLines <\/b>die Anzahl der Zeilen des Moduls. Dann durchläuft sie alle Zeilen in einer For…Next<\/b>-Schleife und prüft bei jedem Durchlauf, ob der Name der aktuellen Prozedur, die mit ProcOfLine <\/b>ermittelt wird, mit der aktuell in der Variablen strProcedure <\/b>gespeicherten Prozedur übereinstimmt. Falls nicht, wurde soeben die nächste Prozedur entdeckt und wir können AddErrorHandler <\/b>für diese Prozedur aufrufen.<\/p>\n
Danach durchsucht die Prozedur die weiteren Zeilen und stattet die folgenden Prozeduren mit Fehlerbehandlungen aus – bis die letzte Zeile des Moduls erreicht wurde.<\/p>\n
Alle Module mit Fehlerbehandlungen ausstatten<\/h2>\n
Und auch für das Ausstatten aller Prozeduren aller Module haben wir eine Prozedur vorgesehen. Diese durchläuft lediglich über die Auflistung VBComponents <\/b>des VBProject<\/b>-Objekts alle Module und ruft für jedes einmal die Prozedur AddErrorHandlersToModule<\/b> auf (siehe Listing 4).<\/p>\nPublic Sub <\/span>AddErrorHandlersToActiveVBProject()\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n For Each objVBComponent In objVBProject.VBComponents\r\n Call<\/span> AddErrorHandlersToModule(objVBComponent.Name)\r\n Next<\/span> objVBComponent\r\nEnd Sub<\/span><\/pre>\nListing 4: Prozedur zum Hinzufügen von Fehlerbehandlungen zu allen Prozeduren aller Module eines VBA-Projekts<\/span><\/b><\/p>\nFehlerbehandlung wieder entfernen<\/h2>\n
Natürlich müssen wir auch hier eine Prozedur vorsehen, mit der wir die Fehlerbehandlung wieder entfernen. Diese heißt RemoveErrorHandler <\/b>und erwartet ebenfalls den Namen des Moduls und der zu bearbeitenden Prozedur als Parameter (siehe Listing 5).<\/p>\nPublic Sub <\/span>RemoveErrorHandler(strModule As String<\/span>, strProcedure As String<\/span>)\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>lngCountOfLines As Long<\/span>\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n Dim <\/span>lngProcBodyLine As Long<\/span>\r\n Dim <\/span>lngFirstStatementLineNumber As Long<\/span>\r\n Dim <\/span>lngLastStatementLineNumber As Long<\/span>\r\n Dim <\/span>strProcType As String<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>strLine As String<\/span>\r\n Dim <\/span>strProcbodyline As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n lngCountOfLines = objCodeModule.CountOfLines\r\n lngProcBodyLine = objCodeModule.ProcBodyLine(strProcedure, intProcType)\r\n lngFirstStatementLineNumber = GetFirstStatementLineNumber(objCodeModule, lngProcBodyLine)\r\n lngLastStatementLineNumber = GetLastStatementLineNumber(objCodeModule, lngProcBodyLine)\r\n strProcbodyline = GetProcBodyLine(objCodeModule, lngProcBodyLine)\r\n strProcType = GetProcType(strProcedure, strProcbodyline)\r\n For lngLine = lngFirstStatementLineNumber To lngLastStatementLineNumber\r\n strLine = Trim<\/span>(objCodeModule.Lines(lngLine, 1))\r\n Select Case True<\/span>\r\n Case <\/span>strLine = \"On Error Goto Errorhandling\", strLine = \"\"\r\n objCodeModule.DeleteLines lngLine\r\n lngLine = lngLine - 1\r\n Case <\/span>strLine = \"Exit \" & strProcType & \" ''Errorhandling\", strLine = \"\"\r\n objCodeModule.DeleteLines lngLine\r\n lngLine = lngLine - 1\r\n Case <\/span>strLine = \"Errorhandling:\", strLine = \"\"\r\n objCodeModule.DeleteLines lngLine\r\n lngLine = lngLine - 1\r\n Case <\/span>left(strLine, 17) = \"Call<\/span> HandleError(\", strLine = \"\"\r\n objCodeModule.DeleteLines lngLine\r\n lngLine = lngLine - 1\r\n End Select<\/span>\r\n Next<\/span> lngLine\r\nEnd Sub<\/span><\/pre>\nListing 5: Prozedur zum Entfernen von Fehlerbehandlungen aus einer Prozedur<\/span><\/b><\/p>\nSie referenziert das aktuelle VBA-Projekt und holt sich einen Verweis auf das CodeModule<\/b>-Objekt mit dem zu bearbeitenden Code. Dann ermittelt sie die Gesamtzahl der Zeilen des Moduls und die Startzeile der zu bearbeitenden Prozedur. Außerdem benötigen wir die erste und die letzte Zeile innerhalb der Prozedur, also nach der Kopfzeile und vor der Fußzeile. Damit ausgestattet holen wir uns noch die Kopfzeile und ermitteln mit der Funktion strProcType <\/b>den Typ der Prozedur.<\/p>\n
Nun durchlaufen wir in einer For…Next<\/b>-Schleife alle Zeilen innerhalb der Prozedur und fügen jeweils die aktuelle Zeile in die Variable strLine <\/b>ein. In einer Select Case<\/b>-Anweisung prüfen wir im ersten Case<\/b>-Zweig, ob diese Zeile On Error Goto Errorhandling <\/b>lautet. Ist das der Fall, löschen wir die Zeile mit der Delete<\/b>-Methode und setzen die Zählervariable für die aktuelle Zeile wieder um 1 zurück, denn durch das Löschen ist die nächste Zeile ja nun zur aktuellen Zeile geworden, die wir als nächstes untersuchen wollen.<\/p>\n
Der nächste Case<\/b>-Zweig untersucht, ob die Zeile den Text Exit <\/b>plus Prozedurtyp enthält, also Sub<\/b>, Function <\/b>oder Property<\/b>. Auch in diesem Fall soll die Zeile entfernt werden und wir setzen lngLine <\/b>um 1 <\/b>zurück.<\/p>\n
Auch die Zeile Errorhandling: <\/b>soll auf diese Weise entfernt werden. Eine leicht abgewandelte Case<\/b>-Bedingung verwenden wir nur für die Zeile, welche die Prozedur HandleError <\/b>aufruft – hier untersuchen wir nur die ersten 17 Zeichen, da wir danach je nach Modul und Prozedur unterschiedliche Texte vorfinden werden.<\/p>\n
Auf diese Weise entfernen wir die vier hinzugefügten Zeilen recht zuverlässig. Aber was bedeutet „recht zuverlässig“ in diesem Zusammenhang? Die meisten Zeilen können wir genau ermitteln. Es ist nicht davon auszugehen, dass Zeilen namens Errorhandling:<\/b>, On Error Goto ErrorHandling <\/b>oder beginnend mit Call Handle Error(<\/b> anders als durch unsere Prozedur zum Hinzufügen der Fehlerbehandlung in die Prozedur gelangt sind.<\/p>\n
Anders sieht es bei der Zeile Exit Sub<\/b>\/Function<\/b>\/Property <\/b>aus. Diese kann durchaus auch in einem anderen Kontext bereits in der Prozedur vorkommen. Unsere aktuelle Version würde jedoch nun alle Vorkommen dieser Anweisung löschen und damit den Code unter Umständen fehlerhaft machen.<\/p>\n
Also müssen wir uns überlegen, wie wir sicherstellen, dass nur die von uns hinzugefügte Exit…<\/b>-Zeile gelöscht wird. Dazu gibt es folgende Möglichkeiten:<\/p>\n\n- Wir prüfen, ob die nächste Zeile die Sprungmarke Errorhandling: enthält.<\/li>\n
- Oder wir hängen beim Anlegen einen Kommentar an die Zeile an, auf den wir dann prüfen.<\/li>\n<\/ul>\n
Dazu passen wir die letzte Zeile der Prozedur AddErrorHandler <\/b>wie folgt an:<\/p>\nbjCodemodule.InsertLines lngLastStatementLineNumber + 1, _\r\n \" Exit \" & strProcType & \" ''Errorhandling\"<\/pre>\nIn der Prozedur RemoveErrorHandler <\/b>passen wir die entsprechende Case<\/b>-Bedingung so an:<\/p>\nCase <\/span>Trim<\/span>(strLine) = \"Exit \" & strProcType _\r\n & \" ''Errorhandling\", Trim<\/span>(strLine) = \"\"<\/pre>\nAlle Errorhandler eines Moduls entfernen<\/h2>\n
Schließlich wollen wir noch die Möglichkeit bieten, wenn man alle Prozeduren eines Moduls mit Fehlerbehandlungen versehen hat, diese auch wieder zu entfernen. Das erledigen wir mit der Prozedur aus Listing 6, die genauso aufgebaut ist wie die Prozedur AddErrorHandlersToModule<\/b>.<\/p>\nPublic Sub <\/span>RemoveErrorHandlersFromModule(strModule As String<\/span>)\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodemodule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n Dim <\/span>lngCountOfLines As Long<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>strProcedure As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodemodule = objVBComponent.CodeModule\r\n lngCountOfLines = objCodemodule.CountOfLines\r\n For lngLine = 1 To lngCountOfLines\r\n If <\/span>Not<\/span> strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType) Then<\/span>\r\n strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType)\r\n Call<\/span> RemoveErrorHandler(strModule, strProcedure)\r\n End If<\/span>\r\n Next<\/span> lngLine\r\nEnd Sub<\/span><\/pre>\n