{"id":55000641,"date":"2008-12-01T00:00:00","date_gmt":"2021-03-22T16:20:26","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=641"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBAFehlerbehandlung_revolutioniert","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/VBAFehlerbehandlung_revolutioniert\/","title":{"rendered":"VBA-Fehlerbehandlung revolutioniert"},"content":{"rendered":"

\"\"<\/p>\n

Es kracht hin und wieder beim Ausführen Ihres VBA-Codes und Sie klicken auf die Debuggen-Schaltfläche der Fehlermeldung Macht nichts – das kommt vor. Sie verteilen Ihr Werk und der Benutzer berichtet von seltsamen Fenstern und sich öffnendem VBA-Editor Weniger schön. Sie liefern Ihre Datenbank mit der Access-Runtime aus und der Kunde meldet ungehalten, dass sich die Anwendung allenthalben einfach schließe Spätestens dann ist Schluss. Es geht aber auch anders …<\/b><\/p>\n

Die Fehlerbehandlung ist fester Bestandteil jedes Programmcodes – oder sollte es zumindest sein. Es ist sicher legitim, während der Entwicklung einer Prozedur oder eines Moduls Fehlerbehandlungsmechanismen außen vor zu lassen. Das ist im Gegenteil sogar hilfreich, weil bei auftretenden Fehlern der VBA-Debugger an der richtigen Stelle anhält, diese markiert und Sie nun etwa Variablen auf falsche Werte inspizieren können. Sobald jedoch andere Benutzer oder sogar Kunden mit der Anwendung arbeiten, sollten Fehlerbehandlungen in allen Prozeduren eingebaut sein, damit die Benutzer nicht mit kryptischen Meldungen konfrontiert werden oder gar den VBA-Editor zu Gesicht bekommen.<\/p>\n

Besonders wichtig ist das, wenn Ihre Datenbank mit der Runtime-Version von Access gestartet wird, denn diese verzeiht keine Nachlässigkeiten und beendet sich kurzerhand bei jedem unbehandelten Fehler selbst. Das kann auch Datenverlust nach sich ziehen.<\/p>\n

Möglichkeiten zur Fehlerbehandlung von VBA-Routinen wurden in Access im Unternehmen bereits vielfach dargestellt. Ob Sie in den Zweig zur Fehlerauswertung einfach eine schnöde Messagebox setzen, die die Fehlerbeschreibung ausgibt, oder die Fehlerbearbeitung an eine separate Fehlerfunktion delegieren, die sich um Ausgabe, Loggen oder gar Versenden per E-Mail kümmert, von einer Arbeit kann Sie niemand befreien: In jede einzelne Prozedur Ihres Projekts müssen entsprechende Anweisungen geschrieben werden, die das Verhalten bei einem auftretenden Fehler regeln.<\/p>\n

Zwar erleichtern Ihnen Hilfsmittel, wie die MZ-Tools, die Arbeit beim Anlegen eines Rahmens zur Fehlerbehandlung und optional beim Durchnummerieren der Code-Zeilen. Im Eifer des Gefechts wird es Ihnen versehentlich aber sicher immer wieder passieren, dass Sie mal schnell eine Funktion in ein Modul hineinschreiben, die ohne Fehlerbehandlung bleibt. Lehnen Sie sich zurück! Mit dem brandneuen SimplyVBA Global VBA Error Handler<\/b> [1] hat Wayne Phillips von everythingaccess.com <\/b>eine revolutionäre Schnittstelle geschaffen, die Fehlerbehandlung unter VBA auf ein neues Level hebt, ganz neue Konzepte erschließt und Sie in Zukunft ruhig schlafen lässt.<\/p>\n

The SimplyVBA Global Error Handler – SVGEH<\/b><\/p>\n

Der Name Wayne Phillips dürfte den meisten Access-Entwicklern kein Begriff sein. Er ist kaum in Foren präsent, kein MVP und doch möglicherweise der Entwickler mit den tiefsten Kenntnissen zu Interna von Access und VBA weltweit – außerhalb des Microsoft Entwickler-Teams selbstredend.<\/p>\n

Seine englische Firma Everythingaccess.com <\/b>aka iTechMasters dagegen könnte dem einen oder anderen bereits beim Surfen begegnet sein: Dort wird ein Service zum Dekompilieren von Access-MDE-Datenbanken angeboten. Niemand sonst kann seit zwei Jahren einen solchen Dienst anbieten. Karl Donaubauer berichtete in der Ausgabe 4\/2006 von Access im Unternehmen darüber. Ich hatte die Ehre, zur Runde der Beta-Tester des Global Error Handlers zu gehören, mit einigen Vorschlägen an der Entwicklung teilhaben zu dürfen und dabei einige Hintergründe über die Wirkungsweise der Schnittstelle zu erfahren. Rein äußerlich handelt es sich um eine ActiveX-DLL, die, zumindest in der Freeware-Version, in die Verweise der eigenen Datenbank, also des VBA-Projekts, aufgenommen wird. Sie klinkt sich außerdem bei Registrierung, wahlweise über ein Setup oder über regsvr32<\/b>, als COM-Addin in Access ein. Über den Aufruf einer einzigen Methode in der Schnittstellenbibliothek verändert sich der VBA-Debugger komplett und leitet alle Fehlerereignisse an eine wählbare eigene Prozedur weiter – ganz unabhängig davon, wo sich der Fehler ereignet und ob Sie Statements zur Fehlerbehandlung in den Prozeduren Ihres Projekts implementiert haben.<\/p>\n

Selbst Fehler, die im VBA-Direktfenster ausgelöst werden, landen dann bei dieser Prozedur, in deren Ablauf beliebige Fehlerauswertungen vorgenommen werden können.<\/p>\n

Wie hat er das gemacht<\/b><\/p>\n

Bevor ich Ihnen die Verfahrensweisen im Umgang mit dem Global Error Handler beschreibe, soll erwähnt werden, was da intern vor sich geht. Wayne Phillips hat die DLL mit Borland C++ entwickelt und auch vor Assembler-Einsatz nicht Halt gemacht. Der Grund dafür ist, dass das Ausschalten des VBA-internen Debuggers und das Weiterleiten von Fehlerereignissen an eine benutzerdefinierte Funktion sich nur mit einem Patchen der geladenen VBA-System-DLLs erreichen lässt. Das passiert, wohlgemerkt, nur im Access zugewiesenen Arbeitsspeicher und verändert nicht etwa Dateien von Access oder VBA. Um dies zu erreichen, also geschützte Speicherbereiche zu manipulieren, müssen scharfe API-Geschütze aufgefahren werden. Man könnte nun misstrauisch werden, ob solche tief greifenden Manipulationen nicht die Stabilität von VBA gefährden. Tatsächlich kann ich aber seit einigen Versionen der DLL von keinem einzigen Absturz oder irgendwelchen Unzulänglichkeiten oder Fehlfunktionen in allen Testprojekten berichten. Wayne Phillips ist, davon abgesehen, ein zugänglicher Entwickler, der Bugs außerordentlich schnell behebt. Sollten Sie problematisches Verhalten des Error Handlers feststellen, dann zögern Sie nicht, ihm dies in einer kurzen E-Mail mitzuteilen – dann allerdings in Englisch.<\/p>\n

Der VBA-Debugger<\/b><\/p>\n

Ein Ausflug in die Funktionsweise des VBA-Debuggers soll zunächst klären, wie VBA mit Fehlern umgeht.<\/p>\n

Dazu legen wir eine einfache Prozedur an, die absichtlich einen Fehler hervorruft:<\/p>\n

Sub LetItCrash\r\n    Dim obj As Object\r\n    Set obj = CreateObject("Sascha.Trowitzsch")\r\nEnd Sub<\/pre>\n
Hier wird versucht, ein COM-Objekt zu erzeugen, das es (nach meiner Kenntnis) gar nicht gibt. Beim Ausführen der Prozedur werden wir folglich mit dem Fehlerdialog des VBA-Debuggers konfrontiert (siehe Bild 1). Der Benutzer Ihrer Anwendung wird erst mal ratlos sein, was das zu bedeuten hat, und anschließend möglicherweise die Eingabetaste drücken, weil der Begriff Debuggen <\/b>so chic aussieht und ohnehin den Fokus hat.<\/p>\n
\"debugmsg.png\"<\/p>\n
Bild 1: Eine konventionelle VBA-Fehlermeldung<\/span><\/b><\/p>\n
Das jedoch ist der denkbar ungünstigste Fall, weil sich nun ein Fenster öffnet, von dem er noch nicht mal weiß, ob es zu Ihrer Anwendung gehört und ob er hier Daten eingeben soll, weil er bei der Schulung geschlafen hat (siehe Bild 2). Aber verfolgen wir lieber nicht, wie der Benutzer in seiner Verwirrung weiter verfährt… …<\/p>\n
\"debugline.png\"<\/p>\n
Bild 2: Eine Fehlermeldung im VBA-Editor<\/span><\/b><\/p>\n
Was hat VBA gemacht<\/b><\/p>\n
Wenn VBA auf eine Zeile stößt, die es nicht ausführen kann, weil Syntax oder Werte nicht seinen Regeln entsprechen, dann schaut es zunächst nach, in welchem Modus sich sein Debugger befindet. Dieser Modus kann durch On Error<\/b>-Direktiven im Code gesteuert werden. In unserem Prozedurbeispiel gibt es keine solche Direktive und der Modus des Debuggers ist damit quasi auf „Interaktiv“ geschaltet, was bedeutet, dass VBA nun Entscheidungshilfe benötigt, wie es mit dem Fehler weiter umgehen soll. Da es darüber keine Informationen aus dem VBA-Projekt selbst bekommt, fragt es eben beim Benutzer nach und präsentiert den Fehlerdialog, nachdem es vorsorglich den Code in gelb markierter Zeile angehalten hat (siehe Bild 2).<\/p>\n
Wenn Sie die Debuggen-Schaltfläche betätigen, dann gelangen Sie genau zu dieser Zeile und haben nun noch die Möglichkeit, die Zeile syntaktisch oder durch andere Variablenwerte zu korrigieren – etwa die ProgID <\/b>des zu erzeugenden COM-Objekts auf Forms.Form.1<\/b> zu ändern. VBA versucht dann, die korrigierte Zeile nochmals auszuführen. Klicken Sie hingegen die Beenden-Schaltfläche, dann bricht VBA die Ausführung des Codes ab und zerstört nebenbei noch sämtliche lokalen und globalen Variablen, die Sie möglicherweise in Ihrem Projekt untergebracht haben. Der Gedanke dahinter ist der, dass VBA wegen des nicht weiter ausgeführten Codes vorlaut davon ausgeht, dass die Werte der Variablen nun wahrscheinlich eh nicht mehr passen. <\/p>\n
Nicht unerwähnt sollte bleiben, dass dies nur das Verhalten unter der Vollversion von Access ist. Die Runtime-Version erlaubt ja keinen Einblick in die VBA-Entwicklungsumgebung und ein Debuggen-Knopf im Fehlerdialog ergibt somit keinen Sinn. Die Runtime stuft jeden VBA-Fehler als kritisch ein und beendet die Datenbank kurzerhand, nachdem sie den Benutzer recht wortkarg über die Ursache informiert (siehe Bild 3). All diese unschönen Auswirkungen unterlassener Anweisungen zur Fehlerbehandlung lassen sich vermeiden, wenn dem VBA-Debugger gesagt wird, was er im Fehlerfall tun soll. Im Prinzip gibt es nur zwei Modi, die Sie einstellen können. Über On Error Resume Next <\/b>sagen Sie ihm schlicht, dass er nicht ausführbare Zeilen überspringen soll (s. Listing 1).<\/p>\n
Listing 1: Fehler übergehen mit On Error Resume Next<\/p>\n
Sub LetItCrash2()\r\n    Dim obj As Object\r\n    On Error Resume Next\r\n    Set obj = CreateObject("Sascha.Trowitzsch")\r\nEnd Sub<\/pre>\n
\"missing<\/p>\n
Bild 3:  Unbehandelter Fehler unter der Access-Runtime – peng!<\/span><\/b><\/p>\n
Mit On Error Goto Label <\/b>teilen Sie dem Debugger mit, dass er bei nicht ausführbarer Zeile an eine andere Stelle im Code springen soll, die mit einer Zeichenkette, dem Label, gekennzeichnet ist. In diesem Codeabschnitt lassen sich dann weitere Entscheidungen treffen, wie die Ausführung des Codes abschließend aussehen soll (s. Listing 2). Immerhin wird dem Anwender mit dieser Routine eine Meldung angezeigt, die keinen Debuggen-Knopf mehr aufweist, und gesetzte Variablen verlieren auch nicht mehr ihre Werte (siehe Bild 4). <\/p>\n
Listing 2: Fehlerbehandlung mit Sprungmarke<\/p>\n
Sub LetItCrash3()\r\n    Dim obj As Object\r\n    On Error GoTo Fehler\r\n    Set obj = CreateObject("Sascha.Trowitzsch")\r\nEnde:\r\n    Set obj = Nothing\r\n    Exit Sub\r\n \r\nFehler:\r\n    MsgBox Err.Description, vbCritical\r\n    Resume Ende\r\nEnd Sub<\/pre>\n<\/p>\n
Listing 3: Fehlerbehandlung mit Nummerierung und Sprungmarke<\/p>\n
Sub LetItCrash4()\r\n    Dim obj As Object\r\n \r\n    20 On Error GoTo Fehler\r\n    40 Set obj = CreateObject("Sascha.Trowitzsch")\r\n \r\nEnde:\r\n    60 Set obj = Nothing\r\n    80 Exit Sub\r\n \r\nFehler:\r\n    100 MsgBox "Fehler in Zeile " & Erl & _\r\n    " von mdlDemos.LetItCrash4:" & vbCrLf & _\r\n    Err.Description, vbCritical, "Anwendungsfehler"\r\n    120 Resume Ende\r\nEnd Sub<\/pre>\n
\"errormsgbox.png\"<\/p>\n
Bild 4: Fehlermeldung ohne Debugging-Schaltfläche<\/span><\/b><\/p>\n
Davon abgesehen bringt diese Meldung weder den Benutzer, noch den Entwickler wirklich weiter. Was fangen Sie damit an, wenn der User Ihnen am Telefon die Meldung vorliest Sie enthält vor allem keine Informationen darüber, wo der Fehler auftrat. Eine aussagekräftigere Meldung enthielte daher zusätzliche Angaben zu Modulnamen, Prozedurnamen und möglichst auch Zeilennummer der nicht ausführbaren Codezeile (siehe Bild 5). Das lässt sich durch eine Erweiterung der Prozedur wie in Listing 3 erreichen. Die Tatsache, dass der Debugger für die Direktive On Error Goto Label <\/b>immer die Angabe einer Sprungstelle innerhalb (!) der gleichen Prozedur erwartet, führt zu viel Arbeit: In Hunderten von Prozeduren Ihres Projekts müssen Sie die immer gleichen Anweisungen und Fehlerbehandlungsabschnitte einfügen. Und wenn Sie nicht übermäßig pingelig sind, werden Sie dabei immer noch eine Reihe Prozeduren übersehen …<\/p>\n
Listing 4: Die Hauptroutine ruft eine Unterfunktion auf.<\/p>\n
Private strTest As String\r\nPublic globRet As Boolean\r\n \r\nSub LetItCrash5()\r\n    Dim a As Long\r\n    a = 99\r\n    strTest = "Sascha"\r\n    globRet = SubLetItCrash(strTest)\r\nEnd Sub\r\n \r\nFunction SubLetItCrash(strObj As String) As Boolean\r\n    Dim obj As Object\r\n    Set obj = CurrentDb\r\n    Set obj = CreateObject(strObj & ".Trowitzsch")\r\n    SubLetItCrash = obj.Name\r\n    Set obj = Nothing\r\n    SubLetItCrash = True\r\nEnd Function<\/pre>\n<\/p>\n
Listing 5: Variablenliste<\/p>\n
*****************************************************\r\n*** demo_globalerrorhandler.mdlDemos.SubLetItCrash *****************************************************\r\n(PARAM) strObj As String = "Sascha"\r\n(LOCAL) obj As Object = {Object}\r\n(LOCAL) SubLetItCrash As Boolean = False\r\n(MODULE) strTest As String = "Sascha"\r\n(MODULE) globRet As Boolean = False\r\n*****************************************************\r\n*** demo_globalerrorhandler.mdlDemos.LetItCrash5 *****************************************************\r\n(LOCAL) a As Long = 99\r\n(MODULE) strTest As String = "Sascha"\r\n(MODULE) globRet As Boolean = False\r\n*****************************************************<\/pre>\n
\"errormsgbox2.png\"<\/p>\n
Bild 5: Fehlermeldung mit Angabe der VBA-Quellzeile<\/span><\/b><\/p>\n
Und hier setzt der Simply VBA Global Error Handler <\/b>an. Er ermöglicht, dass bei Fehlern nicht das prozedureigene Label angesprungen wird, sondern eine beliebige öffentliche Fehlerbehandlungsprozedur, die Sie dafür umso reichhaltiger ausstatten und mit allen Schikanen zur Fehlerbeschreibung versehen können. Dabei lässt sich der SimplyVBA Global Error Handler<\/b>, den ich ab hier abgekürzt nur noch SVGEH <\/b>nennen werde, durchaus jederzeit über seine Schnittstelle so steuern, dass auch zu einer prozedureigenen Fehlerroutine zurückgesprungen werden kann.<\/p>\n
SVGEH einsetzen<\/b><\/p>\n
Wenn Sie den SVGEH verwenden möchten, dann laden Sie ihn zunächst unter [1] herunter. Es stehen drei Versionen zur Verfügung. Die Freeware-Version kommt erfreulicherweise ohne nervende Popups oder andere Werbemaßnahmen aus und enthält alle wesentlichen Features. Erst, wenn Sie Ihre Anwendung vertreiben wollen, fallen Kosten an, die jedoch relativ bescheiden ausfallen und mit der voraussichtlichen Zeitersparnis schnell wieder hereingeholt sind. Eine Übersicht über Versionsunterschiede finden Sie im Anhang. Die Freeware-Version erfordert die Installation über ein Setup, welches die VBAGlobalErrorHandler.dll <\/b>als ActiveX-Komponente registriert. Die Installation enthält zusätzlich eine umfangreiche Demo-Datenbank, die alle Features gut demonstriert – allerdings in Englisch. Das gilt auch für die Hilfe, die bislang nur online unter [3] verfügbar ist. In der Freeware-Version benötigen Sie in Ihrem VBA-Projekt einen Verweis auf die SimplyVBA Global Error Handler Library<\/b>.<\/p>\n
Für die kommerziellen Versionen ist das nicht zwingend notwendig, weil diese zusätzlich einen Mechanismus anbieten, der das Laden der DLL über VBA-Anweisungen erlaubt. Die DLL muss dann lediglich etwa im Anwendungsordner liegen. Sollte diese auf einem Zielrechner nicht vorhanden sein, dann kann dies ebenfalls über VBA-Code ermittelt und dem Benutzer eine entsprechende Mitteilung für den Support präsentiert werden.<\/p>\n
<\/p>\n
Für den Anfang sollten Sie aber mit Verweis arbeiten, weil Sie so durch IntelliSense unterstützt werden, und können nach Abschluss des Projekts auf die verweislose Variante umsteigen.<\/p>\n
Übrigens: Der SVGEH lässt sich nicht nur unter Access einsetzen, sondern in allen durch VBA unterstützten Anwendungen wie Excel, Word et cetera. Nebenbei werden Sie nach Installation in der Liste der COM-Add-Ins von Access noch den Eintrag SimplyVBA Compiler Fix for MDEs <\/b>finden, um den Sie sich nicht weiter zu kümmern brauchen. Dieses Add-In benötigt der SVGEH immer dann, wenn MDEs erstellt werden. Und schließlich zeigt der Add-In-Manager von VBA zusätzlich ein weiteres COM-Add-In an, den Simply VBA SourceCode Line Numberer<\/b>, von dem später noch die Rede sein wird. Alle diese Komponenten befinden sich, wohlgemerkt, in der einen installierten DLL.<\/p>\n
SVGEH aktivieren<\/b><\/p>\n
Das zentrale Objekt, das der SVGEH zur Verfügung stellt, ist das ErrEx<\/b>-Objekt. ähnlich, wie das immer aktive Err<\/b>-Objekt von VBA, muss dieses Objekt nicht extra instanziert werden, sondern steht mit dem Laden des Verweises global bereit. Nur wenige Zeilen müssen geschrieben werden, damit Sie Ihre Fehlerbehandlung komplett umstellen:<\/p>\n
ErrEx.EnableGlobalErrorHandler Application, "Fehlerbehandlung"\r\n \r\nFunction Fehlerbehandlung() As Boolean\r\n \r\nEnd Function<\/pre>\n
Die erste Zeile zur Aktivierung des SVGEH können Sie testweise auch im VBA-Direktfenster absetzen. Sinnvoll ist natürlich, dass Sie diese letztlich in einer öffentlichen Funktion unterbringen, die später vom AutoExec-Makro beim Start der Anwendung aufgerufen wird. Die Methode EnableGlobalErrorHandler <\/b>deaktiviert das eingebaute Verhalten des VBA-Debuggers. Sie übergeben der Methode einen Verweis auf das Application-Objekt sowie den Namen einer öffentlichen Prozedur, die bei Fehlern ausgeführt werden soll. Statt einer Function können Sie ebenso eine Sub-Prozedur einsetzen. Fehlt diese Routine im Quellcode, dann meldet sich der SVGEH mit der Info in Bild 6.<\/p>\n
\"noerrfunction.png\"<\/p>\n
Bild 6: Der SVGEH meldet, wenn eine Fehlerbehandlungsroutine fehlt<\/span><\/b><\/p>\n
Obwohl die Angabe der Fehlerbehandlungsprozedur obligatorisch ist, braucht sie keinen Inhalt zu haben. Das Standardverhalten des SVGEH in diesem Fall ist, dass ein Dialog mit umfangreichen Angaben zum auslösenden Fehler erscheint. Führen Sie die Prozedur LetItCrash <\/b>der Beispieldatenbank (demo_globalerrorhandler.mdb<\/b>) wie oben aus, dann präsentiert sich ohne weiteres Zutun etwa ein Dialog wie in Bild 7.<\/p>\n
\"globerrmsg1.png\"<\/p>\n
Bild 7: Der Error Report des einbauten SVGEH-Fehlerdialogs<\/span><\/b><\/p>\n
Sie sehen: Neben Fehlernummer und -beschreibung, also Angaben, die auch der übliche Fehlerdialog von VBA bereithält, finden sich noch mehr Informationen, wie Datum und Uhrzeit des Fehlerereignisses, die Prozedur und sogar die Quellcodezeile im Volltext. <\/p>\n
Mega-Features<\/b><\/p>\n
Ein Klick auf den Button Show call stack <\/b>enthüllt schließlich noch die Aufrufreihenfolge der Prozeduren, die dem Fehler vorausgegangen war, wie in Bild 8. Es ist dort etwa zu erkennen, dass die Funktion LetItCrash <\/b>vom VBA-Direktfenster aus aufgerufen wurde (VBE.Immediate.Window<\/b>). Ein weiteres Feature ist allerdings den kommerziellen Versionen des SVGEH <\/b>vorbehalten und zeigt sich durch Vorhandensein der Schaltfläche Show Variables<\/b>. Wird diese angeklickt, so öffnet sich eine Übersicht mit den Inhalten aller (!) Variableninhalte, die zum Zeitpunkt des Fehlers gesetzt waren. Für Analysezwecke ist dies eine unschätzbare Unterstützung.<\/p>\n
\"globerrmsgcallstack.png\"<\/p>\n
Bild 8: Der SVGEH kann auch die Reihenfolge der Prozeduraufrufe ermitteln.<\/span><\/b><\/p>\n
Um die Funktion der beiden letztgenannten Features etwas besser zu verdeutlichen, ist in Listing 4 eine etwas vertracktere Version unseres LetItCrash<\/b>-Moduls angegeben.<\/p>\n
Listing 6: Variablenliste<\/p>\n
Function Fehlerbehandlung() As Boolean\r\n    With ErrEx\r\n    Select Case .Number\r\n    Case 429\r\n    .Description = "COM-Objekt konnte nicht erstellt werden"\r\n    End Select\r\n \r\n    .Description = .Description & vbCrLf & "(" & .SourceModule & "." & .SourceProcedure & _\r\n    " Z." & .SourceLineNumber & ")"\r\n    End With\r\nEnd Function<\/pre>\n
Der Aufruf von LetItCrash5 <\/b>aus einem Makro heraus führt dann zum Call Stack <\/b>(Prozeduraufrufliste) in Bild 9.<\/p>\n
\"callstack.png\"<\/p>\n
Bild 9: Informationen zum Call Stack im Fehlerdialog des SVGEH<\/span><\/b><\/p>\n
Zu lesen ist diese Liste von unten nach oben. Zuerst wurde die Funktion LetItCrash5 <\/b>im VBA-Direktfenster aufgerufen, danach rief diese ihrerseits die Function SubLetItCrash <\/b>auf, in der sich der eigentliche Fehler ereignete. Beteiligt waren die Zeilen #3 und #2 – davon wird gleich noch die Rede sein.<\/p>\n
Der Klick auf den Button Show Variables <\/b>öffnet die Variablenliste aus Listing 5.<\/p>\n
Hier sind nicht nur die Variablennamen, -typen und -werte verzeichnet, sondern auch ihre Gültigkeitsbereiche, fein säuberlich sortiert nach den beteiligten Prozeduren. <\/p>\n
Als wäre das nicht ohnehin schon obercool, der Hammer kommt erst noch: Das alles funktioniert auch in einer MDE und\/oder Runtime!<\/p>\n
Sollten Sie also bisher der beruhigenden Annahme erlegen sein, dass in einer MDE kein Quelltext mehr vorhanden sei – ist er eigentlich auch nicht! -, dann bekommen Sie hiermit eine Kostprobe von Wayne Phillips Fähigkeiten zum Reverse Engineering von P-Code geboten. Lediglich der Text der beteiligten Quellcodezeilen wird bei MDEs nicht wiedergegeben.<\/p>\n
Die Schaltflächen Debug Source Code <\/b>(Debuggen), End <\/b>(Beenden) und Help <\/b>(Hilfe) kennen sie schon aus den herkömmlichen VBA-Fehlermeldungen, und sie verhalten sich auch beim SVGEH analog.<\/p>\n
Neu hingegen ist der Button Ignore and continue<\/b>. Ein Klick darauf kommt einem momentanen On Error Resume <\/b>gleich – die fehlerhafte Zeile wird also übersprungen.<\/p>\n
Unmittelbar danach ist allerdings der gesetzte Fehlerbehandlungsstatus wieder aktiv. Um kurz zusammenzufassen, was das bisher Ausgeführte bedeuten kann:<\/p>\n