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 zukommem 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. Wir wollen in diesem Beitrag eine minimale Fehlerbehandlung verwenden, die nur die n tigsten Informationen aufnimmt. Dazu geh ren die folgenden: Fehlernummer Fehlerbeschreibung Zeile, in welcher der Fehler aufgetreten ist Prozedur, in welcher der Fehler aufgetreten ist Modul, in dem der Fehler aufgetreten ist Woher bekommen wir diese Informationen? 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: On Error Resume Next On Error Goto Sprungmarke Dabei ist Sprunkmarke eine Zeile, die den Namen der Sprungmarke und einen Doppelpunkt enth lt, zum Beispiel: Errorhandling: Wenn wir die eingebaute Fehlerbehandlung wieder einschalten wollen, k nnen wir dies mit der folgenden Anweisung erledigen: On Error Goto 0 W hrend die eingebaute Fehlerbehandlung ausgeschaltet ist, werden Fehler entweder einfach ignoriert (On Error Resume Next) oder der Code wird an der angegebenen Sprungmarke fortgesetzt, wenn eine angegeben wurde (On Error Got Errorhandler). Fehlernummer und Fehlerbeschreibung ermitteln In jedem Fall k nnen wir in den darauffolgenden Zeilen die Eigenschaften des Err-Objekts auslesen. Das k nnen wir zwar immer, aber wenn kein unbehandelter Fehler aufgetreten ist, liefert dies auch keine Fehlerinformationen. Gehen wir jedoch davon aus, dass wir die Informationen nach Auftreten eines Fehlers abfragen, k nnen wir dem Err-Objekt die folgenden Informationen entnehmen: Err.Number: Liefert die Fehlernummer, zum Beispiel 11. Err.Description: Liefert die Fehlerbeschreibung, zum Beispiel Division durch Null. Name des VBA-Projekts ermitteln Wir k nnten mit der Err-Eigenschaft Err.Source 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. Zeilennummer ermitteln Die Nummer der Zeile, in welcher der Fehler aufgetreten ist, finden wir offiziell gar nicht. Allerdings gibt es eine nicht dokumentierte Funktion namens Erl, die uns im Falle eines Fehlers die Nummer der Zeile mit der ausl senden Anweisung liefert. Dies geschieht jedoch auch nur, wenn es auch eine Zeilennummerierung gibt. Diese m ssen wir selbst hinzuf gen, es gibt keine eingebaute Funktion, um dies einfach zu erledigen. Wie wir die Zeilennummer hinzuf gen, haben wir deshalb ausf hrlich beschrieben, und zwar im Beitrag Zeilennummern per VBA hinzuf gen (www.access-im-unternehmen.de/1515). 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. Prozedurname und Modulname ermitteln 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. 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. Das gilt auch, wenn sich nicht die Fehlerbehandlungsanweisungen 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. Das sieht beispielsweise wie folgt aus: Public Sub Test_WriteError() 10 On Error GoTo Errorhandling 20 Debug.Print 1 / 0 30 Exit Sub Errorhandling: HandleError Err.Number, Err.Description, Erl, _ "Test_WriteError", "mdlErrors" End Sub Die Prozedur hat bereits Zeilennummern und die eingebaute Fehlerbehandlung wird mit On Error Goto Errorhandling deaktiviert. Der Fehler durch die Division durch 0 in Zeile 20 f hrt somit dazu, dass die Prozedur direkt zur Sprungmarke Errorhandling springt. Hier rufen wir eine Prozedur namens HandleError 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. Fehlerbehandlungsroutine Die Routine namens HandleError, 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 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. Public Sub HandleError(lngNumber As Long, strMessage As String, lngLine As Long, strProcedure As String, _ strModule As String) Dim db As DAO.Database Set db = CurrentDb db.Execute "INSERT INTO tblErrors(ErrorNumber, ErrorMessage, ErrorLine, ErrorProcedure, ErrorModule) VALUES(" _ lngNumber ", ''" Replace(strMessage, "''", "''''") "'', " lngLine ", ''" strProcedure "'', ''" _ strModule "'')", dbFailOnError End Sub Listing 1: Fehlerbehandlungsroutine F r dieses legen wir als Standardwert Jetzt() fest, damit wir dieses Feld nicht per Code f llen m ssen (siehe Bild 1). Bild 1: Tabelle zum Speichern der Fehlerinformationen Die Fehlerbehandlungsroutine enth lt im Wesentlichen eine INSERT INTO-Anweisung, die einen neuen Datensatz in die Tabelle tblErrors schreibt und die mit der Execute-Methode des Database-Objekts ausgef hrt wird. Wenn wir unsere Fehlerbehandlung einige Male mit der obigen Beispielprozedur ausl sen, finden wir Eintr ge wie in Bild 2 in der Tabelle tblErrors vor. Bild 2: Tabelle zum Speichern der Fehlerinformationen mit einige Fehlern Alternativen zum Eintrag in die Fehlertabelle 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 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. 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. Fehlerbehandlung anwendungsweit integrieren 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. Das sind aus der Beispielprozedur von oben alle Anweisungen au er Prozedurkopf, -fu und der eigentlichen Anweisung: Public Sub Test_WriteError() 10 On Error GoTo Errorhandling 20 Debug.Print 1 / 0 30 Exit Sub Errorhandling: HandleError Err.Number, Err.Description, Erl, _ "Test_WriteError", "mdlErrors" End Sub Und wenn wir, wie im Beitrag Zeilennummern per VBA hinzuf gen (www.access-im-unternehmen.de/1515) beschrieben, auch Zeilennummern automatisiert zu Prozeduren hinzuf gen k nnen, warum sollen wir dann nicht automatisch die immer wiederkehrenden Zeilen hinzuf gen? Prozedur zum automatisierten Hinzuf gen einer Fehlerbehandlung Hier verwenden wir die Prozedur AddErrorHandler aus Listing 2. Sie erwartet die folgenden Parameter: Public Sub AddErrorHandler(strModule As String, strProcedure As String) Dim objVBProject As VBIDE.VBProject Dim objVBComponent As VBIDE.VBComponent Dim objCodemodule As VBIDE.CodeModule Dim lngCountOfLines As Long Dim intProcType As vbext_ProcKind Dim lngProcBodyLine As Long Dim strProcBodyLine As String Dim lngFirstStatementLineNumber As Long Dim lngLastStatementLineNumber As Long Dim strProcType As String Set objVBProject = VBE.ActiveVBProject Set objVBComponent = objVBProject.VBComponents(strModule) Set objCodemodule = objVBComponent.CodeModule lngCountOfLines = objCodemodule.CountOfLines lngProcBodyLine = objCodemodule.ProcBodyLine(strProcedure, intProcType) lngFirstStatementLineNumber = GetFirstStatementLineNumber(objCodemodule, lngProcBodyLine) lngLastStatementLineNumber = GetLastStatementLineNumber(objCodemodule, lngFirstStatementLineNumber) strProcBodyLine = GetProcBodyLine(objCodemodule, lngProcBodyLine) strProcType = GetProcType(strProcedure, strProcBodyLine) objCodemodule.InsertLines lngFirstStatementLineNumber, " On Error GoTo Errorhandling" objCodemodule.InsertLines lngLastStatementLineNumber + 2, " Call HandleError(Err.Number, Err.Description, _ Erl, """ strProcedure """, """ strModule """)" objCodemodule.InsertLines lngLastStatementLineNumber + 2, "Errorhandling:" objCodemodule.InsertLines lngLastStatementLineNumber + 2, " Exit " strProcType End Sub Listing 2: Prozedur zum Hinzuf gen einer Fehlerbehandlung zu einer Prozedur strModule: Name des Moduls strProcedure: Name der Prozedur, in der die Fehlerbehandlung hinzugef gt werden soll Die Prozedur f llt die Variable objVBProject mit einem Verweis auf das aktuelle VBA-Projekt. Dann ermittelt sie das VBComponent-Objekt zu dem mit strModule angegebenen Modul und referenziert es mit der Variablen objVBComponent. ber ihre Eigenschaft CodeModule holt sie sich einen Verweis auf das CodeModule-Objekt des Moduls. Nun ermittelt sie einige Zeilennummern: lngCountOfLines: Wird mit der Anzahl der Zeilen des Moduls gef llt. lngProcBodyLine: Wird mit der Nummer der ersten Zeile der Prozedur aus strProcedure gef llt. F r den Pflichtparameter ProcKind bergeben wir die leere Variable intProcType. Diese erh lt einen Wert f r den Typ der Prozedur, den wir aber nicht ben tigen. lngFirstStatementLineNumber: Hier ermitteln wir mit der Funktion GetFirstStatementLineNumber die Nummer der Zeile mit der ersten Anweisung der Prozedur, also die erste Zeile hinter der gegebenfalls auch aus mehreren Zeilen bestehenden Kopfzeile. Diese Funktion beschreiben wir im Detail im Beitrag Zeilennummern per VBA hinzuf gen (www.access-im-unternehmen.de/1515). strProcBodyLine: Wird ber die Funktion GetProcBodyLine, 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-Objekt und die erste Zeile der Prozedur. strProcType: Hier ermitteln wir mit der Funktion GetProcType, die wir ebenfalls im oben genannten Beitrag beschreiben, den Typ der Prozedur, und zwar Sub, Function oder Property. lngLastStatementLineNumber: Erh lt die mit der Funktion GetLastStatementLineNumber ermittelte Nummer der letzten Zeile vor der Zeile mit der End -Anweisung. Danach beginnt die eigentliche Aktion: Die erste InsertLines-Methode f gt die Zeile On Error Goto Errorhandling an Stelle der mit lngFirstStatementLineNumber angegebenen ersten Zeile der Prozedur ein. Die n chste Anweisung beginnt mit dem Einf gen der Zeilen am Ende der Prozedur. Damit 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. Danach f gen wir die Zeile mit der Sprungmarke ein, was wiederum die beiden letzten Zeilen nach hinten verschiebt. Schlie lich folgt noch die Anweisung Exit Sub/Exit Function/Exit Property, damit die Prozedur bei regul ren Verlauf vor Erreichen der Fehlerbehandlung verlassen wird. Auf diese Weise k nnen wir einer Prozedur in einem Modul die gew nschte Fehlerbehandlung hinzuf gen. Fehlerbehandlungen zu allen Prozeduren eines Moduls hinzuf gen Mit der Prozedur AddErrorHandlersToModule, die den Namen des Moduls als Parameter erwartet, rufen wir die Prozedur AddErrorHandler f r jede Prozedur des angegebenen Moduls auf (siehe Listing 3). Public Sub AddErrorHandlersToModule(strModule As String) Dim objVBProject As VBIDE.VBProject Dim objVBComponent As VBIDE.VBComponent Dim objCodemodule As VBIDE.CodeModule Dim intProcType As vbext_ProcKind Dim lngCountOfLines As Long Dim lngLine As Long Dim strProcedure As String Set objVBProject = VBE.ActiveVBProject Set objVBComponent = objVBProject.VBComponents(strModule) Set objCodemodule = objVBComponent.CodeModule lngCountOfLines = objCodemodule.CountOfLines For lngLine = 1 To lngCountOfLines If Not strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType) Then strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType) Call AddErrorHandler(strModule, strProcedure) End If Next lngLine End Sub Listing 3: Prozedur zum Hinzuf gen von Fehlerbehandlungen zu allen Prozeduren eines Moduls Die Prozedur ermittelt Verweise auf das aktuelle VBA-Projekt und das betroffenen CodeModule-Objekt und ermittelt f r die Variable lngCountOfLines die Anzahl der Zeilen des Moduls. Dann durchl uft sie alle Zeilen in einer ForNext-Schleife und pr ft bei jedem Durchlauf, ob der Name der aktuellen Prozedur, die mit ProcOfLine ermittelt wird, mit der aktuell in der Variablen strProcedure gespeicherten Prozedur bereinstimmt. Falls nicht, wurde soeben die n chste Prozedur entdeckt und wir k nnen AddErrorHandler f r diese Prozedur aufrufen. Danach durchsucht die Prozedur die weiteren Zeilen und stattet die folgenden Prozeduren mit Fehlerbehandlungen aus bis die letzte Zeile des Moduls erreicht wurde. Alle Module mit Fehlerbehandlungen ausstatten Und auch f r das Ausstatten aller Prozeduren aller Module haben wir eine Prozedur vorgesehen. Diese durchl uft lediglich ber die Auflistung VBComponents des VBProject-Objekts alle Module und ruft f r jedes einmal die Prozedur AddErrorHandlersToModule auf (siehe Listing 4). Public Sub AddErrorHandlersToActiveVBProject() Dim objVBProject As VBIDE.VBProject Dim objVBComponent As VBIDE.VBComponent Set objVBProject = VBE.ActiveVBProject For Each objVBComponent In objVBProject.VBComponents Call AddErrorHandlersToModule(objVBComponent.Name) Next objVBComponent End Sub Listing 4: Prozedur zum Hinzuf gen von Fehlerbehandlungen zu allen Prozeduren aller Module eines VBA-Projekts Fehlerbehandlung wieder entfernen Nat rlich m ssen wir auch hier eine Prozedur vorsehen, mit der wir die Fehlerbehandlung wieder entfernen. Diese hei t RemoveErrorHandler und erwartet ebenfalls den Namen des Moduls und der zu bearbeitenden Prozedur als Parameter (siehe Listing 5). Public Sub RemoveErrorHandler(strModule As String, strProcedure As String) Dim objVBProject As VBIDE.VBProject Dim objVBComponent As VBIDE.VBComponent Dim objCodemodule As VBIDE.CodeModule Dim lngCountOfLines As Long Dim intProcType As vbext_ProcKind Dim lngProcBodyLine As Long Dim lngFirstStatementLineNumber As Long Dim lngLastStatementLineNumber As Long Dim strProcType As String Dim lngLine As Long Dim strLine As String Dim strProcbodyline As String Set objVBProject = VBE.ActiveVBProject Set objVBComponent = objVBProject.VBComponents(strModule) Set objCodemodule = objVBComponent.CodeModule lngCountOfLines = objCodemodule.CountOfLines lngProcBodyLine = objCodemodule.ProcBodyLine(strProcedure, intProcType) lngFirstStatementLineNumber = GetFirstStatementLineNumber(objCodemodule, lngProcBodyLine) lngLastStatementLineNumber = GetLastStatementLineNumber(objCodemodule, lngProcBodyLine) strProcbodyline = GetProcBodyLine(objCodemodule, lngProcBodyLine) strProcType = GetProcType(strProcedure, strProcbodyline) For lngLine = lngFirstStatementLineNumber To lngLastStatementLineNumber strLine = objCodemodule.Lines(lngLine, 1) Select Case True Case Trim(strLine) = "On Error Goto Errorhandling", Trim(strLine) = "" objCodemodule.DeleteLines lngLine lngLine = lngLine - 1 Case Trim(strLine) = "Exit " strProcType, Trim(strLine) = "" objCodemodule.DeleteLines lngLine lngLine = lngLine - 1 Case Trim(strLine) = "Errorhandling:", Trim(strLine) = "" objCodemodule.DeleteLines lngLine lngLine = lngLine - 1 Case left(Trim(strLine), 17) = "Call HandleError(", Trim(strLine) = "" objCodemodule.DeleteLines lngLine lngLine = lngLine - 1 End Select Next lngLine End Sub Listing 5: Prozedur zum Entfernen von Fehlerbehandlungen aus einer Prozedur Sie referenziert das aktuelle VBA-Projekt und holt sich einen Verweis auf das CodeModule-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 den Typ der Prozedur. Nun durchlaufen wir in einer ForNext-Schleife alle Zeilen innerhalb der Prozedur und f gen jeweils die aktuelle Zeile in die Variable strLine ein. In einer Select Case-Anweisung pr fen wir im ersten Case-Zweig, ob diese Zeile On Error Goto Errorhandling lautet. Ist das der Fall, l schen wir die Zeile mit der Delete-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. Der n chste Case-Zweig untersucht, ob die Zeile den Text Exit plus Prozedurtyp enth lt, also Sub, Function oder Property. Auch in diesem Fall soll die Zeile entfernt werden und wir setzen lngLine um 1 zur ck. Auch die Zeile Errorhandling: soll auf diese Weise entfernt werden. Eine leicht abgewandelte Case-Bedingung verwenden wir nur f r die Zeile, welche die Prozedur HandleError aufruft hier untersuchen wir nur die ersten 17 Zeichen, da wir danach je nach Modul und Prozedur unterschiedliche Texte vorfinden werden. 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:, On Error Goto ErrorHandling oder beginnend mit Call Handle Error( anders als durch unsere Prozedur zum Hinzuf gen der Fehlerbehandlung in die Prozedur gelangt sind. Anders sieht es bei der Zeile Exit Sub/Function/Property 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. Also m ssen wir uns berlegen, wie wir sicherstellen, dass nur die von uns hinzugef gte Exit-Zeile gel scht wird. Dazu gibt es folgende M glichkeiten: Wir pr fen, ob die n chste Zeile die Sprungmarke Errorhandling: enth lt. Oder wir h ngen beim Anlegen einen Kommentar an die Zeile an, auf den wir dann pr fen. Dazu passen wir die letzte Zeile der Prozedur AddErrorHandler wie folgt an: bjCodemodule.InsertLines lngLastStatementLineNumber + 1, _ " Exit " strProcType " ''Errorhandling" In der Prozedur RemoveErrorHandler passen wir die entsprechende Case-Bedingung so an: Case Trim(strLine) = "Exit " strProcType _ " ''Errorhandling", Trim(strLine) = "" Alle Errorhandler eines Moduls entfernen 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. Public Sub RemoveErrorHandlersFromModule(strModule As String) Dim objVBProject As VBIDE.VBProject Dim objVBComponent As VBIDE.VBComponent Dim objCodemodule As VBIDE.CodeModule Dim intProcType As vbext_ProcKind Dim lngCountOfLines As Long Dim lngLine As Long Dim strProcedure As String Set objVBProject = VBE.ActiveVBProject Set objVBComponent = objVBProject.VBComponents(strModule) Set objCodemodule = objVBComponent.CodeModule lngCountOfLines = objCodemodule.CountOfLines For lngLine = 1 To lngCountOfLines If Not strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType) Then strProcedure = objCodemodule.ProcOfLine(lngLine, intProcType) Call RemoveErrorHandler(strModule, strProcedure) End If Next lngLine End Sub Listing 6: Prozedur zum Entfernen von Fehlerbehandlungen aus allen Prozeduren eines Moduls Alle Errorhandler des VBA-Projekts entfernen Und zu guter Letzt noch eine Prozedur, mit der wir die zuvor genannte Prozedur f r jedes Modul des aktuellen VBA-Projekts aufrufen. Diese ist ebenfalls genauso aufgebaut wie die Prozedur AddErrorHandlersToActiveVBProject (siehe Listing 7). Public Sub RemoveErrorHandlersFromActiveVBProject() Dim objVBProject As VBIDE.VBProject Dim objVBComponent As VBIDE.VBComponent Set objVBProject = VBE.ActiveVBProject For Each objVBComponent In objVBProject.VBComponents Call RemoveErrorHandlersFromModule(objVBComponent.Name) Next objVBComponent End Sub Listing 7: Prozedur zum Entfernen von Fehlerbehandlungen aus allen Prozeduren aller Module eines VBA-Projekts Zusammenfassung und Ausblick Damit haben wir Routinen, um Fehlerbehandlungen zu Prozeduren, Modulen oder vollst ndigen VBA-Projekten hinzuf gen k nnen. Im Beitrag Zeilennummern per VBA hinzuf gen (www.access-im-unternehmen.de/1515) zeigen wir, wie man die ben tigten Zeilennummer ebenfalls automatisiert hinzuf gen und wieder entfernen kann. Schlie lich nutzen wir beide L sungen, um wie in Fehler in der Runtime von Access finden (www.access-im-unternehmen.de/1513) beschrieben Fehler unter anderen in Runtime-Anwendungen zu finden. The post Fehlerbehandlung per VBA hinzuf gen appeared first on Access im Unternehmen.
Das Prinzip You Aint Gonna Need It (YAGNI) in der Softwareentwicklung besagt, dass Sie keinen Code oder Funktionen hinzufgen sollten, die Sie aktuell nicht bentigen, um zuknftige Anforderungen vorwegzunehmen. Stattdessen sollten Sie sich auf die aktuell
zum Artikel gehen# Bluetooth-Basiswissen: - Systemarchitektur - Bluetooth-Profile - Klassen und Reichweite - Fehlerbehandlung - Physische Datenkanle / Bluetooth-Basisband - Verbindungsaufbau - Bluetooth-Protokollarchitektur - Energiesparmodi / Bluetooth Low Energy
zum Artikel gehen- berlebens-Kit fr den Umgang mit Node.js und NPM (notwendig, da alle Tools rund um Angular auf Node.js aufbauen) - Kurzeinfhrung in TypeScript mit Wiederholung der wichtigsten JavaScript-Konzepte (Annahme: Alle Teilnehmerinnen und Teilnehmer haben Java
zum Artikel gehen// 250g Kichererbsen ber Nacht einweichen, dann Wasser abgieen und Kichererbsen absplen, anschlieend mit einem TL Backpulver weich kochen. Das Kochwasser abgieen und die Kichererbsen mit dem Prierstab (oder ein
zum Artikel gehenberblick ber Architektur, Techniken und Werkzeuge zur Entwicklung von iOS-Apps - Kerndienste und Schichten - Einschrnkungen des iOS und Lsungsstrategien Entwicklungsumgebung - Hardwarevoraussetzungen - iPhone Dev Center - Xcode - iOS Software Dev
zum Artikel gehen