Fehlersuche und -behandlung mit Access

Wenn Sie bereits einmal Datenbankanwendungen mit VBA-Funktionen und -Prozeduren entwickelt haben, kennen Sie bereits das Vergnügen, sich mit dem Auffinden und Beheben der unterschiedlichsten Fehler herumzuschlagen – es sei denn, Sie programmieren so gut, dass nie Fehler auftreten. Im vorliegenden Beitrag erfahren Sie, welche Fehlerarten bei der Arbeit mit VBA auftreten können, wie man die Fehler findet und sie schließlich behebt. Dabei lernen Sie auch die unterschiedlichen Möglichkeiten der Fehlersuche kennen.

Fehlerarten in VBA

Die Fehlerarten, die bei der Programmierung mit VBA auftreten, können in drei unterschiedliche Gruppen eingeteilt werden.

Syntaxfehler

Die erste Gruppe beinhaltet die so genannten Syntaxfehler. Syntaxfehler erkennt Access entweder direkt bei der Eingabe oder spätestens beim Kompilieren. Ein häufig anzutreffender Fehler bei der Eingabe ist eine zu viel gesetzte Klammer. Auf solche Fehler weist Access Sie nach dem Verlassen der betroffenen Zeile durch eine entsprechende Fehlermeldung in einem Meldungsfenster hin (s. Abb. 1). In der Regel handelt es sich bei Syntaxfehlern um solche Fehler, die Access beim Überprüfen der aktuellen Zeile entdecken kann.

image001.png

Abb. 1: Access bemängelt Syntaxfehler direkt bei der Eingabe.

Möglicherweise möchten Sie nicht, dass Access Fehlermeldungen bei der Eingabe anzeigt. Dann öffnen Sie mit dem Menübefehl Extras|Optionen den Dialog Optionen und wählen hier das Register Modul aus. Hier können Sie sowohl unter Code-Optionen die Anzeige von Fehlermeldungen deaktivieren als auch im Bereich Code-Farben die Textfarbe syntaktisch falscher Zeilen einstellen (s. Abb. 2).

image003.png

Abb. 2: Optionen zur Anzeige von Fehlermeldungen

Wenn Sie die Fehlermeldung ignorieren und die Prozedur dennoch ausführen, weist Access mit einer etwas weniger informativen Meldung auf den Syntaxfehler hin. Immerhin markiert Access die entsprechende Zeile rot, an welcher es zu Problemen kommt.

Kompilierzeitfehler

Manche Fehler, die eigentlich als Syntaxfehler zu bezeichnen sind, fallen bei der Syntaxprüfung während der Eingabe durchs Sieb. Dabei handelt es sich beispielsweise um For…Next-Schleifen, die nicht mit der Next-Anweisung abgeschlossen wurden.

Solche Fehler erfordern die Überprüfung des gesamten Algorithmus. Da bei der Eingabe von Codes nicht nach jeder Zeile eine komplette Überprüfung stattfinden kann, erfolgt sie erst beim Kompilieren der Prozedur oder Funktion.

Eine Funktion oder Prozedur wird kompiliert, wenn Sie diese ausführen. Sie können eine Funktion aber auch kompilieren, ohne sie auszuführen. Dazu verwenden Sie einen der ersten drei Befehle des Menüs Testen.

Mit den Befehlen Alle Module kompilieren und Alle Module kompilieren und speichern kompilieren Sie alle Module. Der Befehl Geladene Module kompilieren schließt nicht geladene Module sowie die Objektmodule von Formularen und Berichten aus. Abb. 3 zeigt eine Prozedur, die einen typischen Kompilierzeitfehler aufweist. In diesem Zusammenhang ist zu erwähnen, dass immer nur ein Kompilierzeitfehler gleichzeitig gemeldet werden kann, da Access das Kompilieren nach dem Auffinden eines Fehlers automatisch abbricht. Weitere Fehler findet Access erst beim folgenden Kompiliervorgang.

image005.png

Abb. 3: Ein typischer Kompilierzeitfehler

Syntax- oder Kompilierzeitfehler sind recht schnell behoben, da man meist direkt eine recht eindeutige Beschreibung des Fehlers erhält. Man korrigiert den Fehler und kompiliert anschließend das Modul erneut, um zu überprüfen, ob der Fehler auch tatsächlich behoben wurde.

Laufzeitfehler

Manche Fehler können nicht bei der Eingabe oder beim Kompilieren festgestellt werden, da sie erst bei der Ausführung der Prozedur auftreten. Dabei gibt es die unterschiedlichsten Möglichkeiten:

  • Einer Variablen wird ein Wert eines anderen Datentyps zugewiesen, etwa ein String einer Integer-Variablen.
  • Der Wert einer Variablen übersteigt deren Wertebereich.
  • Eine Anweisung bezieht sich auf ein Objekt, welches nicht zur Verfügung steht.

Der klassische Vertreter der Laufzeitfehler ist die Division zweier Zahlen, wobei der Benutzer als Teiler den Wert 0 angibt. Hier tritt eine Division durch Null auf, worauf Access wie in Abb. 4 reagiert.

image007.png

Abb. 4: Bei der Division durch Null tritt ein Fehler auf.

Um diesen Fehler zu verhindern, gibt es zwei Möglichkeiten: Entweder Sie setzen direkt bei der Eingabe der Werte an und geben eine entsprechende Meldung aus, wenn der Wert Null für den Nenner eingegeben wurde. Dies können Sie mit einer einfachen Anweisung erledigen (If Zahl1 = 0 then …). Oder Sie überprüfen erst nach der Berechnung, ob ein Fehler aufgetreten ist. In diesem Fall legen Sie eine Fehlerbehandlung an. Wie das geht, erfahren Sie weiter unten.

Logische Fehler

Zur unbequemsten Fehlerart gehören logische Fehler. Während Access sich in den meisten Fällen beim Auftreten der bisher genannten Fehler früher oder später zu Wort meldet, müssen Sie logische Fehler selbst finden und beheben.

Ein einfacher logischer Fehler wäre beispielsweise das falsche Setzen einer Klammer bei einer Rechenoperation, denn (2+2) x 2 ist nicht dasselbe wie 2+(2×2). Wenn Sie komplizierte Berechnungen in Ihrer Anwendung durchführen und am Ende einen unerwarteten Wert erhalten, ist meist ein solch trivialer Fehler schuld am Dilemma.

Access bietet aber auch hier beim Auffinden des Fehlers Hilfestellung. Es gibt beispielsweise zahlreiche Möglichkeiten, Variable während der Laufzeit auszugeben. Wie das funktioniert, erfahren Sie weiter unten.

Starten von Prozeduren

Bevor Sie die folgenden Beispiele ausprobieren, erfahren Sie zunächst, wie Sie eine Prozedur starten können, wenn dies nicht durch das Betätigen einer Schaltfläche passiert. Die schnellste Art, eine Prozedur zu starten, während Sie den Programmcode im Modulfenster sehen, ist das Betätigen des Menübefehls Auswählen|Weiter oder der gleichnamigen Schaltfläche in der Symbolleiste. Achten Sie darauf, dass sich die Einfügemarke in der gewünschten Prozedur befindet, damit Access weiß, welche Prozedur es ausführen soll.

Das funktioniert allerdings nur, wenn der Aufruf der Prozedur keinerlei Parameter erfordert. Falls dies doch der Fall ist, bleibt Ihnen die Möglichkeit, die Prozedur über das Testfenster zu starten. Das Testfenster erreichen Sie entweder über den Menübefehl Ansicht|Testfenster oder über die Tastenkombination Strg + G. Geben Sie hier den Prozedurnamen, gefolgt von den erforderlichen Parametern in der unteren Hälfte des Fensters ein und betätigen Sie die Eingabetaste, um die Prozedur zu starten. Beachten Sie, dass Sie bei privaten Prozeduren den Namen des Moduls mit einem Punkt getrennt voranstellen (etwa modTest.TextAnzeigen). Wenn Sie Prozeduren aus Berichts- oder Formularmodulen ausführen möchten, muss das entsprechende Objekt geöffnet sein, zudem muss es sich um eine öffentliche Prozedur handeln.

Nun haben Sie das erforderliche Werkzeug, um sich an die Beispiele heranzuwagen.

Fehlerbehandlung von Laufzeitfehlern

Die Programmiersprache VBA bietet dem Entwickler die Möglichkeit, auf Laufzeitfehler in angemessener Weise zu reagieren. Das bedeutet, dass Sie Access anweisen können, beim Auftreten eines bestimmten Fehlers in eine Fehlerbehandlungsroutine zu springen, welche dann überprüft, um welchen Fehler es sich handelt, und die entsprechenden Maßnahmen ausführt.

Die folgenden Anweisungen stellen das “Gerippe” einer Prozedur zur Fehlerbehandlung dar:

Sub <Prozedurname> (<Parameterliste>)
    On Error Goto <Sprungmarke>
    [<Anweisungen>]
    Exit Sub
<Sprungmarke>:
    <Anweisungen zur Fehlerbehandlung>
    Exit Sub
End Sub

Dabei legt die Anweisung On Error Goto <Sprungmarke> fest, dass die Prozedur im Fall eines Laufzeitfehlers mit dem Programmteil hinter der angegebenen Sprungmarke fortfährt. In diesem Programmteil können Sie dann die notwendigen Anweisungen geben, welche die Prozedur beim Auftreten eines Fehlers ausführen soll.

Die On Error-Anweisung muss nicht unbedingt auf eine Fehlerbehandlungsroutine verweisen. Sie können auch die Anweisung On Error Resume Next verwenden, um die fehlerhafte Zeile einfach zu überspringen und die Prozedur mit der nächsten Zeile fortzusetzen.

Die Funktionsweise der Fehlerbehandlung lässt sich am besten anhand eines kleinen Beispiels darstellen. Dazu verwenden Sie die Prozedur Dividieren, die Sie bereits weiter oben kennen gelernt haben. Damit der Fehler entsprechend abgefangen wird, müssen Sie einige Zeilen zum vorhandenen Programmcode hinzufügen (siehe hierzu Listing 1).

Listing 1: Benutzerdefinierte Fehlermeldung

Sub Dividieren()
    Dim Zahl1 As Double
    Dim Zahl2 As Double
    Dim Ergebnis As Double
    On Error GoTo Err_Dividieren
    Zahl1 = Val(InputBox("Geben Sie die erste Zahl ein."))
    Zahl2 = Val(InputBox("Geben Sie die zweite Zahl ein."))
    Ergebnis = Zahl1 / Zahl2
    MsgBox ("Das Ergebnis lautet: " & Ergebnis)
    Exit Sub
Err_Dividieren:
    MsgBox "Es ist ein Fehler aufgetreten." & Chr$(10) & _
        "Fehlertext: " & Err.Description & Chr$(10) & _
        "Fehlernummer: " & Err.Number
    Exit Sub
End Sub

Mit der Anweisung On Error Goto Err_Dividieren teilen Sie der Prozedur mit, dass sie beim Auftreten eines Fehlers automatisch in die Fehlerbehandlungsroutine springt, die mit der Sprungmarke Err_Division: eingeleitet wird.

Im vorliegenden Fall gibt die Fehlerbehandlungsroutine statt der üblichen Fehlermeldung eine benutzerdefinierte Fehlermeldung aus (s. Abb. 5).

image038.png

Abb. 5: Eine benutzerdefinierte Fehlermeldung

Wie hier zu erkennen ist, können sowohl die Fehlernummer als auch die Beschreibung des Fehlers ermittelt werden. Dies ermöglicht Ihnen, die Prozedur auf bestimmte Fehlerarten vorzubereiten.

In diesem Fall ist das die Division durch Null. In der folgenden Variante soll die Fehlermeldung den Anwender auf die falsche Eingabe hinweisen und zur Eingabe des ersten Wertes zurückspringen.

Dazu fügen Sie eine weitere Sprungmarke hinzu, mit der die Eingabe nach der Durchführung der Fehlerroutine neu gestartet werden kann.

Außerdem erstellen Sie in der Fehlerbehandlung eine Select Case-Abfrage, die abhängig von der Fehlernummer eine bestimmte Maßnahme ergreift.

Im vorliegenden Fall soll die Prozedur beim Auftreten einer Division durch Null automatisch nach einer Fehlermeldung zurück zur Fehlerausgabe springen. Bei allen anderen Fehlern soll der Ablauf der Prozedur enden. Die Prozedur sieht nun wie in Listing 2 aus.

Listing 2: Individuelle benutzerdefinierte Fehlermeldung

Sub Dividieren()
    Dim Zahl1 As Double
    Dim Zahl2 As Double
    Dim Ergebnis As Double
    On Error GoTo Err_Dividieren
    Werteingabe:
    Zahl1 = Val(InputBox("Geben Sie die erste Zahl ein."))
    Zahl2 = Val(InputBox("Geben Sie die zweite Zahl ein."))
    Ergebnis = Zahl1 / Zahl2
    MsgBox ("Das Ergebnis lautet: " & Ergebnis)
    Exit Sub
Err_Dividieren:
    Select Case Err.Number
        Case 11
            MsgBox "Sie haben den Wert Null als Teiler eingegeben. Geben Sie bitte eine reelle Zahl ein."
            Resume Werteingabe:
        Case Else
            MsgBox "Es ist ein Fehler aufgetreten." & Chr$(10) & "Fehlertext: " & Err.Description _
                  & Chr$(10) & "Fehlernummer: " & Err.Number
            Exit Sub
    End Select
End Sub

Parameter der Resume-Anweisung

Die Resume-Anweisung können Sie wie in obigem Beispiel verwenden, um aus der Fehlerroutine in das Programm zurückzuspringen. Für die Anweisung gibt es drei unterschiedliche Parameter:

  • Resume: Die Prozedur wird mit dem Befehl fortgesetzt, durch den der Fehler verursacht wurde.
  • Resume Next: Die Prozedur wird mit dem ersten Befehl hinter der Anweisung fortgesetzt, die den Fehler ausgelöst hat.
  • Resume <Sprungmarke>: Die Prozedur wird an der Stelle fortgesetzt, die durch die angegebene Sprungmarke eingeleitet wird.

Wirkungsbereich der Fehlerbehandlung

Die Fehlerbehandlung wird durch die On Error-Anweisung aktiviert und endet spätestens mit dem Ende der Prozedur. Dabei gibt es zwei Besonderheiten:

  • Sie können die Fehlerbehandlung auch vor dem Prozedurende mit der Anweisung On Error Goto 0 deaktivieren.
  • Wenn die Prozedur eine weitere Prozedur oder Funktion aufruft, während die Fehlerbehandlung aktiviert ist, gilt die Fehlerbehandlung auch hier als aktiviert. Das Gleiche gilt auch für weitere Verschachtelungen.

Das Objekt Err

Die obigen Beispiele verwendeten bereits einige Eigenschaften des Objekts Err. Hierbei handelt es sich um ein Visual-Basic-Objekt. Jedes Mal, wenn ein Fehler auftritt, speichert Visual Basic einige Informationen zu dem Fehler in dem Objekt. Im Allgemeinen verwendet man nur die Eigenschaften Err.Number, um die Nummer eines Fehlers abzufragen und entsprechend darauf zu reagieren, und die Eigenschaft Err.Description, um die Fehlerbeschreibung unerwarteter Laufzeitfehler auszugeben.

Unerwartete Laufzeitfehler

Wenn in einer Prozedur die Fehlerbehandlung aktiviert ist, enthält die Prozedur meist auch eine Fehlerbehandlungsroutine, die auf die Behandlung bestimmter Fehler vorbereitet ist. Das ist auch in obigem Beispiel der Fall – die Eingabe des Wertes Null als Nenner wird durch die Fehlerbehandlung kompensiert, indem die Eingabe wiederholt wird. Man kann aber meist nicht alle Fehler vorhersehen und gibt daher eine allgemeine Vorgehensweise an, die bei solchen unerwarteten Fehlern – etwa beim Beenden der Prozedur – anzuwenden ist.

Im vorherigen Beispiel wurden Fehler, die nicht die Fehlernummer 11 hatten, durch eine selbstdefinierte Meldung angezeigt – zum Beispiel beim Eingeben von Zahlenwerten anstatt Buchstaben (s. Abb. 6).

image037.png

Abb. 6: Eine benutzerdefinierte Fehlermeldung einen für einen unerwarteten Fehler …

Dies ist die einzige Möglichkeit, den unerwarteten Fehler mit einer Fehlermeldung anzuzeigen und anschließend die Prozedur abzubrechen. Bedingt wird das durch die Tatsache, dass der Fehler durch die Fehlerbehandlung abgefangen wurde. Es gibt aber einen Trick, um dennoch die vom System gesteuerte Fehlermeldung anzuzeigen (Abb. 7): Erzeugen Sie den Fehler in der Fehlerbehandlungsroutine einfach erneut. Die Fehlerbehandlung ist nun nicht mehr aktiviert, da sie jeweils nur einen Fehler abfangen kann.

image013.png

Abb. 7: … und die gewohnte Access-Fehlermeldung

Um den Fehler erneut zu erzeugen, ersetzen Sie die Anweisung im Case Else-Teil der Fehlerbehandlung durch die folgenden Anweisungen:

Dim Fehlernummer As Integer
Fehlernummer = Err.Number
Err.Clear
Err.Raise Fehlernummer

Die erste Anweisung deklariert eine Variable namens Fehlernummer. Die Variable speichert die Nummer des Fehlers, bevor die aktuellen Informationen des Fehlerobjektes Err gelöscht werden. Anschließend erzeugt die Anweisung Err.Raise Fehlernummer erneut den Fehler mit der angegebenen Nummer. Tritt nun ein unerwarteter Fehler auf, erscheint die gewohnte Access-Fehlermeldung (s. Abb. 7).

Fehlersuche

Wenn ein Laufzeitfehler auftritt, kann Access Ihnen eine große Hilfe beim Finden des Fehlers sein. Wenn Access nämlich einen Fehler wie beispielsweise in Abb. 7 findet, haben Sie die Wahl zwischen drei und vier Möglichkeiten, die Sie durch das Betätigen der entsprechenden Schaltflächen auswählen können. Wählen Sie die Schaltfläche Testen, aktiviert Access den Unterbrechungsmodus und zeigt im Modulfenster die fehlerhafte Zeile an (s. Abb. 8). In manchen Fällen können Sie das Programm einfach durch einen Klick auf die Schaltfläche Weiter fortsetzen.

image020.png

Abb. 8: Diese Zeile dient als Haltepunkt.

Sie können die Prozedur auch einfach beenden, ohne die fehlerhafte Stelle anzeigen zu lassen. Falls Sie trotz des Hinweises auf die fehlerhafte Zeile im Dunkeln tappen, betätigen Sie doch einfach einmal die Schaltfläche Hilfe. Access zeigt dann einen Text an, der mögliche Gründe für den eingetretenen Fehler anzeigt.

Der Unterbrechungsmodus

Im Unterbrechungsmodus finden Sie in der Symbolleiste von Access drei Schaltflächen, die Ihnen im Folgenden helfen werden:

  • Wenn Sie den Fehler erkannt haben, können Sie ihn direkt beheben und durch Betätigen der Pfeil-Schaltfläche mit der Ausführung des Programms fortfahren.
  • Die Schaltfläche mit dem Viereck beendet die Programmausführung und Access löscht alle lokalen und privaten Variablen.
  • Mit der Schaltfläche mit dem Pfeil nach links können Sie das Programm ebenfalls beenden. Dabei werden alle Variablen gelöscht.

Beim Auffinden logischer Programmfehler können Ihnen diese Schaltflächen jedoch nicht helfen. Schließlich gelangen Sie gar nicht erst in den Unterbrechungsmodus, da es sich bei einem logischen Fehler ja meist nicht um einen Fehler handelt, den Access erkennt.

In diesem Fall müssen Sie sich selbst auf die Suche machen. Aber auch dabei stellt Access Ihnen einige Hilfsmittel zur Verfügung.

Suchen logischer Programmfehler

Bei der Suche nach logischen Programmfehlern ist es meist hilfreich, die Werte von Variablen an bestimmten Stellen der Prozedur anzeigen zu lassen. Um das zu ermöglichen, müssen Sie zunächst einen Punkt festlegen, an dem die Prozedur angehalten werden soll, um die gewünschten Werte abzufragen.

Das Abfragen von aktuellen Variableninhalten ist zwar auch möglich, wenn das Programm durch einen Laufzeitfehler in den Unterbrechungsmodus gesetzt wurde, aber Sie können den Unterbrechungsmodus auch manuell aktivieren.

Um ein Programm an einer bestimmten Stelle anzuhalten, gehen Sie folgendermaßen vor:

  • Öffnen Sie die Prozedur im Modulfenster.
  • Klicken Sie mit der rechten Maustaste auf die gewünschte Zeile, um das Kontextmenü zu öffnen.
  • Wählen Sie den Menübefehl Umschalten|Haltepunkt.

Wenn Sie die Prozedur einmal in der Entwurfsansicht geöffnet haben, geht es auch noch einfacher: Klicken Sie mit der linken Maustaste in Höhe der gewünschten Zeile auf den grauen Rand links von der Zeile.

Beide Methoden haben das gleiche Ergebnis: Die Zeile wird rot unterlegt und zusätzlich durch einen roten Punkt im linken Bereich des Modulfensters markiert (s. Abb. 8). Um einen Haltepunkt wieder zu entfernen, klicken Sie entweder auf den roten Punkt oder wählen Sie über das Kontextmenü der Zeile erneut den Befehl Umschalten|Haltepunkt aus.

Vorteilhaft ist es, wenn Sie ungefähr abschätzen können, in welcher Prozedur und an welcher Stelle der Fehler ungefähr auftritt. Sie können dann an der entsprechenden Stelle einen Haltepunkt setzen und von dort aus das Programm in kleinen Schritten untersuchen.

Wenn Sie das Programm nun starten, hält es an der angegebenen Stelle an. Access zeigt im Modulfenster die aktuelle Zeile an. Hier haben Sie nun folgende Möglichkeiten, die Sie beispielsweise über das Menü Debuggen aufrufen können (s. Abb. 9):

image039.png

Abb. 9: Menü mit weiteren Debug-Befehlen

  • Haltepunkt ein/aus: Entfernen des Haltepunktes in der aktuellen Zeile
  • Einzelschritt: Führt einen Einzelschritt aus, d. h., dass Access die aktuell markierte Anweisung ausführt.
  • Prozedurschritt: Führt einen Prozedurschritt aus. Wenn Sie diese Schaltfläche innerhalb der aktuellen Prozedur verwenden, wird jeder Befehl als Einzelschritt ausgeführt. Erst das Aufrufen eines Befehls, der eine weitere Prozedur aufruft, bewirkt das Ausführen der kompletten “Unterprozedur” ohne weitere Einzelschritte.
  • Prozedur abschließen: Führt einen Rücksprung aus. Dabei werden die verbleibenden Anweisungen der aktuellen Prozedur ausgeführt und es wird zur aufrufenden Prozedur zurückgesprungen, wo dann erneut angehalten wird.
  • Menü Anzeige|Aufrufeliste: Zeigt die Namen der Datenbank, des Moduls sowie der Prozedur der aktuellen und der aufrufenden Prozedur bis zur obersten Ebene an (s. Abb. 10).

image028.png

Abb. 10: Die Aufrufreihenfolge einer Prozedur

Abfrage von Variablen im Unterbrechungsmodus

Wenn Sie sich im Unterbrechungsmodus befinden und die Anwendung Schritt für Schritt durchlaufen, um anhand der Variablenwerte zu den unterschiedlichen Zeitpunkten logische Fehler ausfindig zu machen, haben Sie mehrere Möglichkeiten, die entsprechenden Werte anzuzeigen.

Die erste Möglichkeit besteht darin, den Mauszeiger im Unterbrechungsfenster über der gewünschten Variablen zu positionieren. Der Wert wird dann per Tooltip-Text angezeigt (s. Abb. 11).

image030.png

Abb. 11: Variablenwerte im Codefenster

Abfrage von Variablen im Testfenster

Das Testfenster dient nicht nur dem Starten von Prozeduren, sondern kann auch zur Ermittlung und Ausgabe von Variablenwerten verwendet werden.

Die einfachste Möglichkeit, einen Wert im Testfenster auszugeben, ist der Befehl Debug.Print. Wenn Sie diesen Befehl gefolgt von einem Ausdruck in eine Prozedur einfügen, gibt Access den angegebenen Ausdruck im Testfenster aus.

Während sich eine Prozedur im Unterbrechungsmodus befindet, können Sie über das Testfenster die aktuellen Variablenwerte einzeln ausgeben lassen und sie bei Bedarf ändern.

Die manuelle Ausgabe der Variablen ist aber in den meisten Fällen nicht erforderlich, da dies in der oberen Hälfte des Testfensters, dem so genannten Lokalbereich, automatisch geschieht. Wenn Sie beispielsweise einen Haltepunkt bei der Ausgabe des Ergebnisses der Prozedur Division setzen, sieht das Testfenster wie in Abb. 12 aus.

image032.png

Abb. 12: Anzeige von Variablen im Testfenster

Noch komfortabler ist die kontrollierte Überwachung von Variablen. Im Gegensatz zur Ausgabe einer Variablen via VBA-Anweisung oder im lokalen Teil des Testfensters können Sie hier gezielt Variablen festlegen, die während der Laufzeit angezeigt werden. Um eine Variable zu überwachen, gehen Sie folgendermaßen vor:

  • Klicken Sie mit der rechten Maustaste auf die gewünschte Variable, um das Kontextmenü anzuzeigen.
  • Wählen Sie den Befehl Überwachung hinzufügen aus.
  • Passen Sie die Parameter im Dialog Überwachung hinzufügen an.

Access fügt den Namen der Variablen automatisch in das Textfeld Ausdruck ein (s. Abb. 13). Im Bereich Kontext können Sie festlegen, in welchem Bereich die Variable überwacht werden soll. Dabei gilt: Die Überwachung einer Variablen kostet immer Ressourcen. Sie sollten deshalb den maximal benötigten Bereich auswählen – also beispielsweise nur Prozeduren, in denen Veränderungen an der Variablen vorgenommen werden. Im Bereich Überwachungsart können Sie festlegen, ob einfach nur der aktuelle Wert der Variablen ausgegeben oder ob beim Erreichen bestimmter Werte die Prozedur angehalten werden soll.

image034.png

Abb. 13: Der Dialog Überwachung hinzufügen

So können Sie beispielsweise im Ausdruck einen Vergleichsausdruck angeben, bei dessen Eintreten die Prozedur angehalten wird, oder Sie wählen die dritte Option und halten damit die Prozedur an, sobald der Wert der Variablen geändert wird.

Um die überwachten Werte betrachten zu können, müssen Sie im oberen Bereich des Testfensters das Register Überwachung aktivieren (s. Abb. 14). Beachten Sie, dass die Anzeige eines Überwachungsausdrucks nur im Einzelschrittmodus funktioniert, während die anderen beiden Optionen für den Laufzeiteinsatz vorgesehen sind.

image036.png

Abb. 14: Überwachung einer Variablen

Schreibe einen Kommentar