<\/p>\n
Die Fehlerbehandlung ist, wenn man sie konsequent betreibt, erstens eine Menge Schreibarbeit und zweitens, wenn man die Fehlerbehandlung halbautomatisch hinzufügt, eine Fehlerquelle. Mit dem Einsatz von vbWatchdog sieht das anders aus. Dieser Beitrag zeigt, wie sich diese Methode der Fehlerbehandlung im Praxiseinsatz bewährt.<\/b><\/p>\n
Das Tool vbWatchdog <\/b>haben wir bereits im Beitrag Fehlerbehandlung mit vbWatchdog <\/b>(www.access-im-unternehmen.de\/779<\/b>) vorgestellt. Im vorliegenden Beitrag schauen wir uns ein Beispiel einer in einer Anwendung eingesetzten Fehlerbehandlung an, die zwei verschiedene Modi zulässt – einen für den Produktiveinsatz und einen für die Entwicklung.<\/p>\n
vbWatchdog <\/b>können Sie unter folgendem Link herunterladen:<\/p>\n Dort gibt es auch eine kostenlose Testversion.<\/p>\n Nach der Installation finden Sie im VBA-Editor einen Menü-Eintrag namens Add-Ins|vbWatchdog|Add vbWatchdog to this project<\/b>, mit dem Sie schlicht und einfach ein paar Klassen zum aktuellen VBA-Projekt hinzufügen. Schließlich müssen Sie die Fehlerbehandlung noch aktivieren, wobei Sie gegebenenfalls sogar verschiedene Fehlerbehandlungen verwenden können.<\/p>\n Im Beispiel dieses Beitrags, der Datenbank aus dem Beitrag Kunden, Verträge und Anschreiben verwalten <\/b>(www.access-im-unternehmen.de\/854<\/b>), kommen gleich zwei verschiedene Fehlerbehandlungen zum Einsatz.<\/p>\n Die erste ist für den Produktiveinsatz gedacht und liefert im Falle eines Fehlers eine Fehlermeldung, die den Benutzer nicht mit unnötigen und nichtssagenden Informationen belastet, sondern diesem schlicht und einfach die Möglichkeit bietet, die Fehlerinformationen zum Entwickler der Anwendung zu senden. Diese Fehlermeldung sieht beispielsweise wie in Bild 1 aus.<\/p>\n Bild 1: Für den Benutzer gedachte Fehlermeldung<\/span><\/b><\/p>\n Ein Klick auf die Schaltfläche Mit Outlook per E-Mail senden <\/b>führt dann zum Öffnen einer E-Mail mit einigen Informationen, die dem Entwickler beim Beheben des Fehlers behilflich sein könnten (s. Bild 2).<\/p>\n Bild 2: Fehlermeldung per E-Mail<\/span><\/b><\/p>\n Der Benutzer kann den Inhalt der Fehlermeldung auch noch in die Zwischenablage kopieren und diese dann selbstständig an den Entwickler versenden – gegebenenfalls existiert auf der Zielmaschine ja gar kein Outlook.<\/p>\n Die zweite Variante der Fehlerbehandlung ist auf die Phase der Entwicklung der Anwendung ausgelegt. Sie soll nur für den Entwickler sichtbar sein und erlaubt auch das Debuggen des Fehlers.<\/p>\n Die in der Beispieldatenbank verwendete Fehlerbehandlung für den Entwicklermodus liefert Fehlermeldungen wie die aus Bild 3.<\/p>\n Bild 3: Entwickler-geeignete Fehlermeldung …<\/span><\/b><\/p>\n Ein Klick auf die Schaltfläche Variablen anzeigen <\/b>liefert auch noch alle Variablen zum Zeitpunkt des Fehlers (s. Bild 4).<\/p>\n Bild 4: … mit Auflistung der Variablen zum Fehlerzeitpunkt<\/span><\/b><\/p>\n Wenn Sie diese Fehlermeldungen einfach übernehmen möchten, gelingt dies recht einfach. Tragen Sie zunächst einen Aufruf wie den folgenden in einer Prozedur ein, die beim Start der Anwendung aufgerufen wird – beispielsweise in die Beim Laden<\/b>-Ereignisprozedur eines Startformulars:<\/p>\n Die dadurch aufgerufene Prozedur finden Sie im Modul mdlError<\/b>, das Sie der Zielanwendung hinzufügen müssen:<\/p>\n Die Prozedur prüft, ob die Funktion Command <\/b>den Wert Developer <\/b>zurückliefert. Hier gibt es eine Querverbindung zum Beitrag Datenbanken im Produktiv- und Entwicklermodus <\/b>(www.access-im-unternehmen.de\/855<\/b>).<\/p>\n Dieser Beitrag beschreibt eine Starter-Datenbank, mit der Sie festlegen können, mit welchen Eigenschaften eine Datenbank gestartet wird.<\/p>\n Dort geben Sie einem Aufruf der Zieldatenbank unter anderem einen Parameter namens cmd <\/b>mit, der beispielsweise den Wert Developer <\/b>enthält. Sollten Sie die Zieldatenbank also mit einer Verknüpfung öffnen, die den Parameter \/cmd "Developer" <\/b>enthält, würde die Funktion Command <\/b>den Wert Developer <\/b>liefern, was wiederum dazu führt, dass die Prozedur Errordialog_Entwickler <\/b>aufgerufen wird. In allen anderen Fällen wird die Prozedur Errordialog_Benutzer <\/b>zum Einrichten der Fehlerbehandlung für diese Instanz der Anwendung aufgerufen.<\/p>\n Die beiden Prozeduren Errordialog_Entwickler<\/b> und Errordialog_Benutzer <\/b>sorgen also für die Einrichtung der Fehlerbehandlung. Schauen wir uns in den folgenden Abschnitten an, wie dies im Detail aussieht.<\/p>\n Entwickler-Fehlermeldung<\/b><\/p>\n Die Fehlermeldung, die der Entwickler zu sehen bekommen soll, wird durch die Prozedur Errordialog_Entwickler <\/b>definiert (s. Listing 1<\/a><\/span>). Diese Prozedur aktiviert auch die Fehlerbehandlung durch vbWatchdog<\/b>. Die erste Anweisung beendet eine eventuell laufende Fehlerbehandlung und startet diese neu. Dass die Methode Err.Enable <\/b>nur eine leere Zeichenkette als Parameter erhält, liegt daran, dass beim Auftreten eines Fehlers keine weiteren Aktionen mit Ausnahme der Anzeige der Fehlermeldung erfolgen sollen.<\/p>\n Listing 1: Einrichten und Aktivieren des Entwickler-Fehlerdialogs<\/p>\n Diese enthält bereits alle notwendigen Informationen, sodass diese nicht etwa in der Zwischenablage oder in einer Tabelle zur weiteren Verarbeitung gespeichert werden müssen. Die folgenden Anweisungen definieren genau, wie die Fehlermeldungen aussehen sollen. Als Erstes legt die Prozedur dabei fest, wie der Hauptfehlerdialog aussehen soll. Das dafür verwendete Objekt heißt DialogOptions<\/b>. Es enthält beispielsweise eine Eigenschaft namens HTML_MainBody<\/b>. Damit legen Sie fest, wie die Meldung aussehen soll. Dabei werden einige Platzhalter wie etwa <ERRDESC><\/b>, <SOURCEPROJ><\/b>, <SOURCEMOD><\/b>, <SOURCEPROJ><\/b>, <ERRNUMBER><\/b>, <ERRDESC><\/b>, <SOURCELINENUMBER><\/b>, <SOURCELINECODE><\/b> und <ERRDATETIME><\/b> verwendet – deren Funktion erklärt sich eigentlich von selbst.<\/p>\n Die Eigenschaft HTML_CallStackItem <\/b>nimmt die Aufrufe der Prozeduren bis zum Fehler und HTML_MoreInfoBody <\/b>die Überschrift für den erweiterten Bereich entgegen. Schauen wir uns an, wo diese Daten für einen einfachen Fehler wie den aus dem folgendem Beispiel landen:<\/p>\n Bild 5 zeigt einige der Bereiche, die per HTML definiert wurden. Wenn Sie auf Details einblenden <\/b>klicken, wird auch noch der mit der Eigenschaft HTML_MoreInfoBody <\/b>festgelegte Bereich sichtbar – der wiederum mit <Callstack> <\/b>den für die Eigenschaft HTML_CallStackItem <\/b>definierten Bereich einbindet. <\/p>\n Bild 5: Verschiedene Bereiche der Fehlermeldung<\/span><\/b><\/p>\n <\/p>\n Die RemoveAllButtons<\/b>-Methode entfernt alle eingebauten Schaltflächen, die folgenden Methoden fügen die gewünschten Schaltflächen hinzu. Dabei erwartet der erste Parameter jeweils die Beschriftung, der zweite fügt eine Konstante für eine der eingebauten Funktionen hinzu.<\/p>\n So erhält die Schaltfläche, welche die Liste der aktuell verwendeten Variablen und ihrer Werte anzeigen soll, die Beschriftung Variablen anzeigen <\/b>als ersten Parameter und die Konstante BUTTONACTION_SHOWVARIABLES <\/b>als zweiten Parameter.<\/p>\n Die Schaltfläche zum Anzeigen weiterer Informationen passen Sie auf eine andere Art an, nämlich indem Sie diese mit der Eigenschaft ShowMoreInfoButton <\/b>einblenden und die Beschriftung mit der Eigenschaft MoreInfoCaption <\/b>anpassen. Gleiches gilt für die Schaltfläche, welche die Details wieder ausblendet.<\/p>\n Den mit der Details einblenden<\/b>-Schaltfläche angezeigten Bereich definieren Sie, wie bereits erwähnt, mit der Eigenschaft HTML_MoreInfoBody<\/b>.<\/p>\n Fehlt noch der Bereich, der beim Klick auf die Schaltfläche Variablen anzeigen <\/b>geöffnet wird (s. Bild 6). Diesen stellen Sie mit den Eigenschaften des Objekts VariablesDialogOptions <\/b>ein.<\/p>\n Bild 6: Übersicht der Variablen<\/span><\/b><\/p>\n Hier werden wieder einige Elemente verschachtelt. HTML_Mainbody <\/b>legt fest, welcher Inhalt im Variablenfenster erscheinen soll. In diesem Fall ist dies <Callstack><\/b>, was mit den einzelnen Callstack-Elementen gefüllt wird.<\/p>\n Deren Aussehen wird durch den Inhalt der Eigenschaft HTML_CallstackItem <\/b>beschrieben. HTML_CallstackItem <\/b>enthält wiederum das Element <VARIABLES><\/b>, das durch eine der Liste der Variablen, formatiert wie in der Eigenschaft HTML_VariableItem <\/b>vorgegeben, ersetzt wird. Auch hier werden wieder alle eingebauten Schaltflächen entfernt und nur eine einzige Schaltfläche mit der Beschriftung Schließen <\/b>hinzugefügt.<\/p>\n Der Entwickler-Fehlerdialog bietet neben der Anzeige der Variablen auch noch die Möglichkeit, einfach den Quellcode zu debuggen – er arbeitet in dieser Hinsicht genau wie der VBA-eigene Fehlerdialog.<\/p>\n Benutzer-Fehlerdialog<\/b><\/p>\n Der Benutzer soll, wie bereits erwähnt, nur die Information erhalten, dass ein Fehler aufgetreten ist, und die Fehlerinformationen möglichst an den Entwickler schicken.<\/p>\n Dies realisieren wir durch einen integrierten Aufruf von Outlook (wir gehen an dieser Stelle davon aus, dass sich auf dem Zielrechner Outlook befindet).<\/p>\n Die Einrichtung des Benutzer-Dialogs sieht deutlich einfacher aus als die des Entwickler-Dialogs (s. Listing 2<\/a><\/span>).<\/p>\n Listing 2: Einrichten und Aktivieren des Benutzer-Fehlerdialogs<\/p>\n Dieser verwendet weitgehend die bereits beschriebenen Elemente, allerdings gibt es auch zwei neue Elemente. Die Definition enthält nämlich zwei benutzerdefinierte Schaltflächen, die nicht die eingebauten Funktionen aufrufen, sondern benutzerdefinierte Funktionen:<\/p>\n Hier gibt der erste Parameter auch wieder die Beschriftung der Schaltfläche an, der zweite jedoch legt die Funktion fest, die beim Anklicken der Schaltfläche durch den Benutzer ausgelöst werden soll.<\/p>\n Dabei soll die erste Schaltfläche eine Funktion namens ErrorMail <\/b>aufrufen, die dazu dient, die Fehlerinformationen per E-Mail an den Entwickler zu senden.<\/p>\n Die zweite ist für den Fall vorgesehen, dass der Benutzer kein Outlook verwendet, die Fehlerinformationen aber dennoch mit seiner individuellen E-Mail-Software versenden möchte. Beide Funktionen schauen wir uns im Anschluss an.<\/p>\n Desweiteren findet sich im Code noch eine interessante änderung: Die Aktivierung der Fehlerbehandlung mit der Enable<\/b>-Methode des ErrEx<\/b>-Objekts geschieht diesmal nämlich nicht mit einer leeren Zeichenkette, sondern mit der Zeichenkette DatenSammeln <\/b>als Wert.<\/p>\n Damit geben Sie den Namen einer Funktion an, die beim Auftreten eines Fehlers ausgelöst werden soll. Warum das, wenn doch bereits Funktionen durch Mausklicks auf entsprechende Schaltflächen der Fehlermeldung ausgeführt werden können Der Grund ist einfach: Nur die hier angegebene Funktion hat Zugriff auf die Fehlerinformationen des ErrEx<\/b>-Objekts.<\/p>\n Das heißt, dass wir an dieser Stelle die Informationen sammeln, in einer Tabelle zwischenspeichern und diese dann, abhängig von der vom Benutzer gewählten Aktion, entweder per E-Mail versenden oder in die Zwischenablage kopieren, damit der Benutzer diese anderweitig weiterverwerten kann.<\/p>\n Die Funktion heißt in diesem Fall DatenSammeln<\/b> und sieht wie in Listing 3<\/a><\/span> aus. Die Prozedur prüft zunächst mit der Eigenschaft State<\/b>, in welchem Kontext der Fehler ausgelöst wurde. Wenn diese Eigenschaft den Wert OnErrorResumeNext <\/b>liefert, bedeutet dies, dass die Fehlerbehandlung zuvor mit der Anweisung On Error Resume Next <\/b>deaktiviert wurde. In diesem Fall soll die Prozedur DatenSammeln <\/b>gleich wieder beendet werden. Dazu noch ein Hinweis: Auch wenn bei durch On Error Resume Next <\/b>deaktivierter Fehlerbehandlung dennoch die Prozedur DatenSammeln <\/b>aufgerufen wird, so zeigt vbWatchdog <\/b>doch keine Fehlermeldung an. Sie könnten also auf diese Weise dennoch protokollieren, ob Fehler in Bereichen, die zuvor mit On Error Resume Next <\/b>behandelt wurden, ausgelöst wurden und wodurch.<\/p>\n Listing 3: Zusammenstellung der Daten für den Fehlerbericht<\/p>\n Die folgenden Anweisungen fügen alle Fehlerinformationen in der Variablen strError<\/b> zu einem längeren Text zusammen. Dazu gehören zunächst für jeden Fehler Informationen wie Datum, Fehlernummer und Beschreibung. Danach durchläuft die Prozedur den Callstack und innerhalb des Callstacks die im jeweiligen Kontext gültigen Variablen. Alle Informationen werden zusammengetragen und schließlich im Feld LetzterFehler <\/b>der Tabelle tblFehler <\/b>gespeichert.<\/p>\n Dabei ist zu beachten, dass etwa die Auflistungen auf verschiedene Arten durchlaufen werden müssen. Zum Durchlaufen des Callstacks etwa wird eine Do…While<\/b>-Schleife verwendet, die so lange läuft, wie die Eigenschaft NextLevel <\/b>den Wert True <\/b>enthält. NextLevel <\/b>liefert allerdings nicht nur die Information, ob der Callstack noch einen weiteren Eintrag enthält, sondern ist gleichzeitig eine Funktion, die den folgenden Eintrag in das Objekt lädt und es über seine Eigenschaften für den Zugriff per VBA verfügbar macht.<\/p>\n Innerhalb eines jeden Callstack-Elements spuckt die Prozedur auch noch alle Variablen samt Inhalt aus. Der Zugriff auf die Variableninhalte per Value<\/b>-Eigenschaft führte jedoch mehrmals zu Fehlern, weil diese schlicht nicht für die Ausgabe beziehungsweise das Anhängen an eine Zeichenkette geeignet waren. Daher prüft die Prozedur nun bereits einige auf diese Weise auffällig gewordenen Objektvariablen auf ihren Typ und gibt entsprechende Ersatzwerte aus, die auf den jeweiligen Objekttyp hinweisen. Das gilt beispielsweise, wenn es sich bei der Variablen um ein Array oder um eine leere Objektvariable handelt.<\/p>\n Die auf diese Weise zusammengestellte Zeichenkette speichert die Prozedur schließlich in einer einfachen Tabelle, die wie in Bild 7 aufgebaut ist.<\/p>\n Bild 7: In der Tabelle tblFehler gespeicherte Fehlerinformationen<\/span><\/b><\/p>\n Listing 4: Speichern der Fehlerinformationen in der Zwischenablage<\/p>\n <\/p>\n Fehlerinformationen per E-Mail versenden<\/b><\/p>\n Abhängig davon, ob der Benutzer sich für einen Klick auf die Schaltfläche Mit Outlook per E-Mail senden <\/b>oder Fehlerinfo in Zwischenablage <\/b>entscheidet, wird eine der beiden Funktionen ErrorClipboard <\/b>(s. Listing 4<\/a><\/span>) oder ErrorMail <\/b>(s. Listing 5<\/a><\/span>) aufgerufen.<\/p>\n<\/p>\n Listing 5: Versenden der Fehlerinformationen per E-Mail<\/p>\n Die Prozedur erstellt zunächst ein Objekt auf Basis der Klasse clsMail<\/b>. Die Beschreibung dieser Klasse finden Sie im Beitrag Mail mit Klasse <\/b>(www.access-im-unternehmen.de\/859<\/b>). Bevor die neue E-Mail gefüllt und versendet wird, trägt die Prozedur in der Variablen strError <\/b>noch einige allgemeine Informationen zusammen – beispielsweise die aktuelle Version der Datenbank, die Access-Version, ob Access als Runtime gestartet wurde, welche Windows-Version im Einsatz ist und wie die Datenbank heißt.<\/p>\n Für Frontend-Backend-Lösungen empfiehlt es sich noch, auch entsprechende Informationen über die Backend-Datenbank zu integrieren. Diese Daten werden um die im Feld LetzterFehler <\/b>der Tabelle tblFehler <\/b>der Datenbank gespeicherten Daten ergänzt und schließlich für die Eigenschaft Inhalt <\/b>des Mail-Objekts eingetragen.<\/p>\n Dieses wird außerdem mit einem Betreff und einem Adressaten ausgestattet. Die Methode Anzeigen <\/b>öffnet die neue E-Mail mit den Fehlerinformationen, damit der Benutzer auch sieht, welche Informationen an den Entwickler gesendet werden.<\/p>\nhttp:\/\/www.everythingaccess.com\/vbwatchdog.htm<\/pre>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2012_05\/FehlerbehandlungInDerPraxis-web-images\/pic001.png\")
<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2012_05\/FehlerbehandlungInDerPraxis-web-images\/pic002.png\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2012_05\/FehlerbehandlungInDerPraxis-web-images\/pic003.png\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2012_05\/FehlerbehandlungInDerPraxis-web-images\/pic004.png\")
<\/p>\nPrivate Sub Form_Load()\r\n ErrEx_Starten\r\n End Sub<\/pre>\n
Public Sub ErrEx_Starten()\r\nIf VBA.Command() = "Developer" Then\r\n Errordialog_Entwickler\r\nElse\r\n Errordialog_Benutzer\r\nEnd If\r\nEnd Sub<\/pre>\n
Public Sub Errordialog_Entwickler()\r\n ErrEx.Disable\r\n ErrEx.Enable ""\r\n With ErrEx.DialogOptions\r\n .HTML_MainBody = "<font face=Arial size=13pt color=""#4040FF""><b>" _\r\n & "Es ist ein Laufzeitfehler aufgetreten.<\/b><\/font><br><br><b><ERRDESC><\/b><br><br>" _\r\n & "Projekt:|<SOURCEPROJ><br>Modul:|<SOURCEMOD><br>Prozedur:|<SOURCEPROC><br>" _\r\n & "Fehlernummer:|<ERRNUMBER><br>Fehlermeldung:|<ERRDESC><br>Zeile:|<SOURCELINENUMBER>" _\r\n & "<br>Zeileninhalt:|<SOURCELINECODE><br>Datum und Zeit:|<ERRDATETIME><br><br><b><u>" _\r\n & "Was möchten Sie tun<\/u><\/b>"\r\n .HTML_CallStackItem = "<b><font color=#303030><SOURCEPROJ>.<SOURCEMOD>.<SOURCEPROC>" _\r\n & "<\/font><\/b><br> |<font bgcolor=#F8F8F8>Zeile <SOURCELINENUMBER>: <i>" _\r\n & "<SOURCELINECODE><\/i><\/font><br>"\r\n .HTML_MoreInfoBody = "<br><b><font face=Arial size=13pt color=#FFFFFF bgcolor=#C0C0C0>" _\r\n & " Aufrufeliste <\/font><\/b><br><br><CALLSTACK>"\r\n .RemoveAllButtons\r\n .AddButton "Variablen anzeigen", BUTTONACTION_SHOWVARIABLES\r\n .AddButton "Quellcode debuggen", BUTTONACTION_ONERRORDEBUG\r\n .AddButton "Ignorieren und fortsetzen", BUTTONACTION_ONERRORRESUMENEXT\r\n .AddButton "Beenden", BUTTONACTION_ONERROREND\r\n .AddButton "Hilfe", BUTTONACTION_SHOWHELP\r\n .MoreInfoCaption = "Details einblenden"\r\n .LessInfoCaption = "Details ausblenden"\r\n .ShowMoreInfoButton = True\r\n .WindowCaption = "Fehler im Projekt ''<SOURCEPROJ>''"\r\n End With\r\n With ErrEx.VariablesDialogOptions\r\n .WindowCaption = "Variablenliste"\r\n .HTML_CallStackItem = "<b><SOURCEPROJ>.<SOURCEMOD>.<SOURCEPROC><\/b><br><br><VARIABLES><br>"\r\n .HTML_MainBody = "<CALLSTACK>"\r\n .HTML_MoreInfoBody = ""\r\n .HTML_VariableItem = "<font color=#808080>(<VARSCOPE>)<\/font>|" _\r\n & "<VARNAME> As <VARTYPE>| = <VARVALUE><br>"\r\n .RemoveAllButtons\r\n .AddButton "Schließen", BUTTONACTION_VARIABLES_CLOSE\r\n End With\r\nEnd Sub<\/pre>\n
Public Sub Fehlerbeispiel()\r\n Dim i As Integer\r\n For i = 3 To 0 Step -1\r\n Debug.Print 1 \/ i\r\n Next i\r\nEnd Sub<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2012_05\/FehlerbehandlungInDerPraxis-web-images\/pic005.png\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2012_05\/FehlerbehandlungInDerPraxis-web-images\/pic006.png\")
<\/p>\nPublic Sub Errordialog_Benutzer()\r\n Dim strMainBody As String\r\n ErrEx.Disable\r\n ErrEx.Enable "DatenSammeln"\r\n With ErrEx.DialogOptions\r\n strMainBody = "<font face=Arial size=13pt color=""#4040FF""><b>Es ist ein Laufzeitfehler " _\r\n & "aufgetreten.<\/b><\/font><br>"\r\n strMainBody = strMainBody & "Sie können helfen, diesen Fehler zu beheben, indem Sie uns " _\r\n & "eine E-Mail mit der Beschreibung des Fehlers zusenden.<br><br>"\r\n strMainBody = strMainBody & "Schicken Sie die Fehlerbeschreibung direkt mit Outlook oder " _\r\n & "kopieren Sie diese in die Zwischenablage und senden Sie sie an ''<Entwickleradresse>''"\r\n .HTML_MainBody = strMainBody\r\n .RemoveAllButtons\r\n .ShowMoreInfoButton = False\r\n .AddCustomButton "Mit Outlook per E-Mail senden", "ErrorMail"\r\n .AddCustomButton "Fehlerinfo in Zwischenablage", "ErrorClipboard"\r\n .AddButton "Beenden", BUTTONACTION_ONERROREND\r\n .DefaultButtonID = 2\r\n .WindowCaption = "Fehler in der Beispieldatenbank zum Buch ''AEMA''"\r\n End With\r\nEnd Sub<\/pre>\n
.AddCustomButton "Mit Outlook per E-Mail senden", "ErrorMail"\r\n.AddCustomButton "Fehlerinfo in Zwischenablage", "ErrorClipboard"<\/pre>\n
Public Sub DatenSammeln()\r\n Dim strError As String\r\n Dim strSQL As String\r\n Dim db As DAO.Database\r\n If ErrEx.State = OnErrorResumeNext Then Exit Sub\r\n Set db = CurrentDb\r\n With ErrEx\r\n strError = strError & "Datum: " & Now & vbCrLf\r\n strError = strError & "Fehlernummer: " & .Number & vbCrLf\r\n strError = strError & "Beschreibung: " & .Description & vbCrLf\r\n With ErrEx.Callstack\r\n Do\r\n strError = strError & " Projektname: " & .ProjectName & vbCrLf\r\n strError = strError & " Modulname: " & .ModuleName & vbCrLf\r\n strError = strError & " Prozedurname: " & .ProcedureName & vbCrLf\r\n strError = strError & " Zeilennummer: " & .LineNumber & vbCrLf\r\n strError = strError & " Zeileninhalt: " & .LineCode & vbCrLf\r\n With ErrEx.Callstack.VariablesInspector\r\n .FirstVar\r\n Do While Not .IsEnd\r\n strError = strError & " Variablenname: " & .Name & vbCrLf\r\n If .Name = "ref" Then\r\n strError = strError & " Variablenwert: Nicht vorhandener Verweis" & vbCrLf\r\n Else\r\n Select Case VarType(.Value)\r\n Case 9\r\n strError = strError & " Variablenwert: " & TypeName(.Value) _\r\n & vbCrLf\r\n Case 13\r\n strError = strError & " Variablenwert: Nothing" & vbCrLf\r\n Case 8200\r\n strError = strError & " Variablenwert: Array" & vbCrLf\r\n Case 0\r\n strError = strError & " Variablenwert: Leer" & vbCrLf\r\n Case Else\r\n strError = strError & " Variablenwert: " & .Value & vbCrLf\r\n End Select\r\n End If\r\n strError = strError & " Datentyp: " & .TypeDesc & vbCrLf\r\n strError = strError & " Gueltigkeitsbereich: " & .Scope & vbCrLf\r\n .NextVar\r\n Loop\r\n End With\r\n Loop While .NextLevel\r\n End With\r\n End With\r\n strSQL = "UPDATE tblFehler SET LetzterFehler = ''" & Replace(strError, "''", "''''") & "''"\r\n db.Execute strSQL, dbFailOnError\r\n If Not Err.Number = 0 Then\r\n strSQL = "INSERT INTO tblFehler(LetzterFehler) VALUES(''" & Replace(strError, "''", "''''") & "'')"\r\n db.Execute strSQL, dbFailOnError\r\n End If\r\nEnd Sub<\/pre>\n![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2012_05\/FehlerbehandlungInDerPraxis-web-images\/pic007.png\")
<\/p>\nPublic Sub ErrorClipboard()\r\n Dim strError As String\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n strError = strError & "Version FE: " & Nz(DLookup("Version_FE", "tblOptionen"), "") & vbCrLf\r\n strError = strError & "Version Access: " & Access.Version & " " & SysCmd(acSysCmdAccessVer) & vbCrLf\r\n strError = strError & "Runtime: " & SysCmd(acSysCmdRuntime) & vbCrLf\r\n strError = strError & "Version Windows: " & GetWindowsVersion & vbCrLf\r\n strError = strError & "Datum: " & Format(Now, "yyyy-mm-dd, hh:nn:ss") & vbCrLf\r\n strError = strError & "Datenbank: " & CodeDb.Name & vbCrLf\r\n strError = strError & db.OpenRecordset("SELECT LetzterFehler FROM tblOptionen", _\r\n dbOpenDynaset).Fields(0)\r\n InZwischenablage strError\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n<\/p>\nPublic Function ErrorMail() As OnErrorStatus\r\n Dim db As DAO.Database\r\n Dim strError As String\r\n Dim objMail As clsMail\r\n Set objMail = New clsMail\r\n Set db = CurrentDb\r\n strError = strError & "Version FE: " & CurrentDb.Containers("Databases"). _\r\n Documents("Userdefined").Properties("Version").Value & vbCrLf\r\n strError = strError & "Version Access: " & Access.Version & " " _\r\n & SysCmd(acSysCmdAccessVer) & vbCrLf\r\n strError = strError & "Runtime: " & SysCmd(acSysCmdRuntime) & vbCrLf\r\n strError = strError & "Version Windows: " & GetWindowsVersion & vbCrLf\r\n strError = strError & "Datum: " & Format(Now, "yyyy-mm-dd, hh:nn:ss") & vbCrLf\r\n strError = strError & "Datenbank: " & CodeDb.Name & vbCrLf\r\n strError = strError & db.OpenRecordset("SELECT LetzterFehler FROM tblFehler", _\r\n dbOpenDynaset).Fields(0)\r\n With objMail\r\n .Betreff = "Fehlermeldung ''AiU''"\r\n .Inhalt = strError\r\n .ToHinzufuegen "andre@minhorst.com"\r\n .Anzeigen\r\n End With\r\n Set db = Nothing\r\n ErrorMail = OnErrorEnd\r\nEnd Function<\/pre>\n