{"id":55000001,"date":"2000-02-01T00:00:00","date_gmt":"2021-03-22T13:09:19","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Fehlersuche_und_behandlung_mit_Access","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/","title":{"rendered":"Fehlersuche und -behandlung mit Access"},"content":{"rendered":"<p><img loading=\"lazy\" decoding=\"async\" src=\"http:\/\/vg02.met.vgwort.de\/na\/e6ee7d7787c74452924c654ed6c43b6b\" width=\"1\" height=\"1\" alt=\"\"><\/p>\n<p><b>Wenn Sie bereits einmal Datenbankanwendungen mit VBA-Funktionen und -Prozeduren entwickelt haben, kennen Sie bereits das Vergn&uuml;gen, sich mit dem Auffinden und Beheben der unterschiedlichsten Fehler herumzuschlagen &#8211; 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&ouml;nnen, wie man die Fehler findet und sie schlie&szlig;lich behebt. Dabei lernen Sie auch die unterschiedlichen M&ouml;glichkeiten der Fehlersuche kennen.<\/b><\/p>\n<h2>Fehlerarten in VBA<\/h2>\n<p>Die Fehlerarten, die bei der Programmierung mit VBA auftreten, k&ouml;nnen in drei unterschiedliche Gruppen eingeteilt werden.<\/p>\n<h2>Syntaxfehler<\/h2>\n<p>Die erste Gruppe beinhaltet die so genannten Syntaxfehler. Syntaxfehler erkennt Access entweder direkt bei der Eingabe oder sp&auml;testens beim Kompilieren. Ein h&auml;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. Bild 1). In der Regel handelt es sich bei Syntaxfehlern um solche Fehler, die Access beim &Uuml;berpr&uuml;fen der aktuellen Zeile entdecken kann.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image001.png\" alt=\"image001.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 1: Access bem&auml;ngelt Syntaxfehler direkt bei der Eingabe.<\/span><\/b><\/p>\n<p>M&ouml;glicherweise m&ouml;chten Sie nicht, dass Access Fehlermeldungen bei der Eingabe anzeigt. Dann &ouml;ffnen Sie mit dem Men&uuml;befehl <b>Extras|Optionen <\/b>den Dialog <b>Optionen <\/b>und w&auml;hlen hier das Register <b>Modul <\/b>aus. Hier k&ouml;nnen Sie sowohl unter Code-Optionen die Anzeige von Fehlermeldungen deaktivieren als auch im Bereich <b>Code-Farben <\/b>die Textfarbe syntaktisch falscher Zeilen einstellen (s. Bild 2).<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image003.png\" alt=\"image003.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 2: Optionen zur Anzeige von Fehlermeldungen<\/span><\/b><\/p>\n<p>Wenn Sie die Fehlermeldung ignorieren und die Prozedur dennoch ausf&uuml;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.<\/p>\n<h2>Kompilierzeitfehler<\/h2>\n<p>Manche Fehler, die eigentlich als Syntaxfehler zu bezeichnen sind, fallen bei der Syntaxpr&uuml;fung w&auml;hrend der Eingabe durchs Sieb. Dabei handelt es sich beispielsweise um <b>For&#8230;Next<\/b>-Schleifen, die nicht mit der Next-Anweisung abgeschlossen wurden.<\/p>\n<p>Solche Fehler erfordern die &Uuml;berpr&uuml;fung des gesamten Algorithmus. Da bei der Eingabe von Codes nicht nach jeder Zeile eine komplette &Uuml;berpr&uuml;fung stattfinden kann, erfolgt sie erst beim Kompilieren der Prozedur oder Funktion.<\/p>\n<p>Eine Funktion oder Prozedur wird kompiliert, wenn Sie diese ausf&uuml;hren. Sie k&ouml;nnen eine Funktion aber auch kompilieren, ohne sie auszuf&uuml;hren. Dazu verwenden Sie einen der ersten drei Befehle des Men&uuml;s <b>Testen<\/b>.<\/p>\n<p>Mit den Befehlen <b>Alle Module kompilieren <\/b>und <b>Alle Module kompilieren und speichern <\/b>kompilieren Sie alle Module. Der Befehl <b>Geladene Module kompilieren <\/b>schlie&szlig;t nicht geladene Module sowie die Objektmodule von Formularen und Berichten aus. Bild 3 zeigt eine Prozedur, die einen typischen Kompilierzeitfehler aufweist. In diesem Zusammenhang ist zu erw&auml;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. <\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image005.png\" alt=\"image005.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 3: Ein typischer Kompilierzeitfehler<\/span><\/b><\/p>\n<p>Syntax- oder Kompilierzeitfehler sind recht schnell behoben, da man meist direkt eine recht eindeutige Beschreibung des Fehlers erh&auml;lt. Man korrigiert den Fehler und kompiliert anschlie&szlig;end das Modul erneut, um zu &uuml;berpr&uuml;fen, ob der Fehler auch tats&auml;chlich behoben wurde.<\/p>\n<h2>Laufzeitfehler<\/h2>\n<p>Manche Fehler k&ouml;nnen nicht bei der Eingabe oder beim Kompilieren festgestellt werden, da sie erst bei der Ausf&uuml;hrung der Prozedur auftreten. Dabei gibt es die unterschiedlichsten M&ouml;glichkeiten:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Einer Variablen wird ein Wert eines anderen Datentyps zugewiesen, etwa ein String einer Integer-Variablen.<\/li>\n<li class=\"aufz-hlung\">Der Wert einer Variablen &uuml;bersteigt deren Wertebereich.<\/li>\n<li class=\"aufz-hlung\">Eine Anweisung bezieht sich auf ein Objekt, welches nicht zur Verf&uuml;gung steht.<\/li>\n<\/ul>\n<p>Der klassische Vertreter der Laufzeitfehler ist die Division zweier Zahlen, wobei der Benutzer als Teiler den Wert <b>0 <\/b>angibt. Hier tritt eine Division durch Null auf, worauf Access wie in Bild 4 reagiert.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image007.png\" alt=\"image007.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 4: Bei der Division durch Null tritt ein Fehler auf.<\/span><\/b><\/p>\n<p>Um diesen Fehler zu verhindern, gibt es zwei M&ouml;glichkeiten: Entweder Sie setzen direkt bei der Eingabe der Werte an und geben eine entsprechende Meldung aus, wenn der Wert <b>Null <\/b>f&uuml;r den Nenner eingegeben wurde. Dies k&ouml;nnen Sie mit einer einfachen Anweisung erledigen (<b>If Zahl1 = 0 then &#8230;<\/b>). Oder Sie &uuml;berpr&uuml;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.<\/p>\n<h2>Logische Fehler<\/h2>\n<p>Zur unbequemsten Fehlerart geh&ouml;ren logische Fehler. W&auml;hrend Access sich in den meisten F&auml;llen beim Auftreten der bisher genannten Fehler fr&uuml;her oder sp&auml;ter zu Wort meldet, m&uuml;ssen Sie logische Fehler selbst finden und beheben.<\/p>\n<p>Ein einfacher logischer Fehler w&auml;re beispielsweise das falsche Setzen einer Klammer bei einer Rechenoperation, denn <b>(2+2) x 2 <\/b>ist nicht dasselbe wie <b>2+(2&#215;2)<\/b>. Wenn Sie komplizierte Berechnungen in Ihrer Anwendung durchf&uuml;hren und am Ende einen unerwarteten Wert erhalten, ist meist ein solch trivialer Fehler schuld am Dilemma.<\/p>\n<p>Access bietet aber auch hier beim Auffinden des Fehlers Hilfestellung. Es gibt beispielsweise zahlreiche M&ouml;glichkeiten, Variable w&auml;hrend der Laufzeit auszugeben. Wie das funktioniert, erfahren Sie weiter unten.<\/p>\n<h2>Starten von Prozeduren<\/h2>\n<p>Bevor Sie die folgenden Beispiele ausprobieren, erfahren Sie zun&auml;chst, wie Sie eine Prozedur starten k&ouml;nnen, wenn dies nicht durch das Bet&auml;tigen einer Schaltfl&auml;che passiert. Die schnellste Art, eine Prozedur zu starten, w&auml;hrend Sie den Programmcode im Modulfenster sehen, ist das Bet&auml;tigen des Men&uuml;befehls <b>Ausw&auml;hlen|Weiter <\/b>oder der gleichnamigen Schaltfl&auml;che in der Symbolleiste. Achten Sie darauf, dass sich die Einf&uuml;gemarke in der gew&uuml;nschten Prozedur befindet, damit Access wei&szlig;, welche Prozedur es ausf&uuml;hren soll.<\/p>\n<p>Das funktioniert allerdings nur, wenn der Aufruf der Prozedur keinerlei Parameter erfordert. Falls dies doch der Fall ist, bleibt Ihnen die M&ouml;glichkeit, die Prozedur &uuml;ber das Testfenster zu starten. Das Testfenster erreichen Sie entweder &uuml;ber den Men&uuml;befehl <b>Ansicht|Testfenster <\/b>oder &uuml;ber die Tastenkombination <b>Strg + G<\/b>. Geben Sie hier den Prozedurnamen, gefolgt von den erforderlichen Parametern in der unteren H&auml;lfte des Fensters ein und bet&auml;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 <b>modTest.TextAnzeigen<\/b>). Wenn Sie Prozeduren aus Berichts- oder Formularmodulen ausf&uuml;hren m&ouml;chten, muss das entsprechende Objekt ge&ouml;ffnet sein, zudem muss es sich um eine &ouml;ffentliche Prozedur handeln.<\/p>\n<p>Nun haben Sie das erforderliche Werkzeug, um sich an die Beispiele heranzuwagen.<\/p>\n<h2>Fehlerbehandlung von Laufzeitfehlern<\/h2>\n<p>Die Programmiersprache VBA bietet dem Entwickler die M&ouml;glichkeit, auf Laufzeitfehler in angemessener Weise zu reagieren. Das bedeutet, dass Sie Access anweisen k&ouml;nnen, beim Auftreten eines bestimmten Fehlers in eine Fehlerbehandlungsroutine zu springen, welche dann &uuml;berpr&uuml;ft, um welchen Fehler es sich handelt, und die entsprechenden Ma&szlig;nahmen ausf&uuml;hrt.<\/p>\n<p>Die folgenden Anweisungen stellen das &#8222;Gerippe&#8220; einer Prozedur zur Fehlerbehandlung dar:<\/p>\n<pre>Sub &lt;Prozedurname&gt; (&lt;Parameterliste&gt;)\r\n    On Error Goto &lt;Sprungmarke&gt;\r\n    [&lt;Anweisungen&gt;]\r\n    Exit Sub\r\n&lt;Sprungmarke&gt;:\r\n    &lt;Anweisungen zur Fehlerbehandlung&gt;\r\n    Exit Sub\r\nEnd Sub<\/pre>\n<p>Dabei legt die Anweisung <b>On Error Goto &lt;Sprungmarke&gt; <\/b>fest, dass die Prozedur im Fall eines Laufzeitfehlers mit dem Programmteil hinter der angegebenen Sprungmarke fortf&auml;hrt. In diesem Programmteil k&ouml;nnen Sie dann die notwendigen Anweisungen geben, welche die Prozedur beim Auftreten eines Fehlers ausf&uuml;hren soll.<\/p>\n<p>Die <b>On Error<\/b>-Anweisung muss nicht unbedingt auf eine Fehlerbehandlungsroutine verweisen. Sie k&ouml;nnen auch die Anweisung <b>On Error Resume Next <\/b>verwenden, um die fehlerhafte Zeile einfach zu &uuml;berspringen und die Prozedur mit der n&auml;chsten Zeile fortzusetzen.<\/p>\n<p><!--30percent--><\/p>\n<p>Die Funktionsweise der Fehlerbehandlung l&auml;sst sich am besten anhand eines kleinen Beispiels darstellen. Dazu verwenden Sie die Prozedur <b>Dividieren<\/b>, die Sie bereits weiter oben kennen gelernt haben. Damit der Fehler entsprechend abgefangen wird, m&uuml;ssen Sie einige Zeilen zum vorhandenen Programmcode hinzuf&uuml;gen (siehe hierzu <a href=\"#anker-44-anchor\">Listing 1<\/a>).<\/p>\n<p class=\"listingueberschrift\">Listing 1: Benutzerdefinierte Fehlermeldung<\/p>\n<pre>Sub Dividieren()\r\n    Dim Zahl1 As Double\r\n    Dim Zahl2 As Double\r\n    Dim Ergebnis As Double\r\n    On Error GoTo Err_Dividieren\r\n    Zahl1 = Val(InputBox(&quot;Geben Sie die erste Zahl ein.&quot;))\r\n    Zahl2 = Val(InputBox(&quot;Geben Sie die zweite Zahl ein.&quot;))\r\n    Ergebnis = Zahl1 \/ Zahl2\r\n    MsgBox (&quot;Das Ergebnis lautet: &quot; &amp; Ergebnis)\r\n    Exit Sub\r\nErr_Dividieren:\r\n    MsgBox &quot;Es ist ein Fehler aufgetreten.&quot; &amp; Chr$(10) &amp; _\r\n        &quot;Fehlertext: &quot; &amp; Err.Description &amp; Chr$(10) &amp; _\r\n        &quot;Fehlernummer: &quot; &amp; Err.Number\r\n    Exit Sub\r\nEnd Sub<\/pre>\n<p>Mit der Anweisung <b>On Error Goto Err_Dividieren <\/b>teilen Sie der Prozedur mit, dass sie beim Auftreten eines Fehlers automatisch in die Fehlerbehandlungsroutine springt, die mit der Sprungmarke <b>Err_Division: <\/b>eingeleitet wird.<\/p>\n<p>Im vorliegenden Fall gibt die Fehlerbehandlungsroutine statt der &uuml;blichen Fehlermeldung eine benutzerdefinierte Fehlermeldung aus (s. Bild 5).<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image038.png\" alt=\"image038.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 5: Eine benutzerdefinierte Fehlermeldung<\/span><\/b><\/p>\n<p>Wie hier zu erkennen ist, k&ouml;nnen sowohl die Fehlernummer als auch die Beschreibung des Fehlers ermittelt werden. Dies erm&ouml;glicht Ihnen, die Prozedur auf bestimmte Fehlerarten vorzubereiten.<\/p>\n<p>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&uuml;ckspringen.<\/p>\n<p>Dazu f&uuml;gen Sie eine weitere Sprungmarke hinzu, mit der die Eingabe nach der Durchf&uuml;hrung der Fehlerroutine neu gestartet werden kann.<\/p>\n<p>Au&szlig;erdem erstellen Sie in der Fehlerbehandlung eine <b>Select Case<\/b>-Abfrage, die abh&auml;ngig von der Fehlernummer eine bestimmte Ma&szlig;nahme ergreift.<\/p>\n<p>Im vorliegenden Fall soll die Prozedur beim Auftreten einer Division durch Null automatisch nach einer Fehlermeldung zur&uuml;ck zur Fehlerausgabe springen. Bei allen anderen Fehlern soll der Ablauf der Prozedur enden. Die Prozedur sieht nun wie in <a href=\"#anker-45-anchor\">Listing 2<\/a> aus.<\/p>\n<p class=\"listingueberschrift\">Listing 2: Individuelle benutzerdefinierte Fehlermeldung<\/p>\n<pre>Sub Dividieren()\r\n    Dim Zahl1 As Double\r\n    Dim Zahl2 As Double\r\n    Dim Ergebnis As Double\r\n    On Error GoTo Err_Dividieren\r\n    Werteingabe:\r\n    Zahl1 = Val(InputBox(&quot;Geben Sie die erste Zahl ein.&quot;))\r\n    Zahl2 = Val(InputBox(&quot;Geben Sie die zweite Zahl ein.&quot;))\r\n    Ergebnis = Zahl1 \/ Zahl2\r\n    MsgBox (&quot;Das Ergebnis lautet: &quot; &amp; Ergebnis)\r\n    Exit Sub\r\nErr_Dividieren:\r\n    Select Case Err.Number\r\n        Case 11\r\n            MsgBox &quot;Sie haben den Wert Null als Teiler eingegeben. Geben Sie bitte eine reelle Zahl ein.&quot;\r\n            Resume Werteingabe:\r\n        Case Else\r\n            MsgBox &quot;Es ist ein Fehler aufgetreten.&quot; &amp; Chr$(10) &amp; &quot;Fehlertext: &quot; &amp; Err.Description _\r\n                  &amp; Chr$(10) &amp; &quot;Fehlernummer: &quot; &amp; Err.Number\r\n            Exit Sub\r\n    End Select\r\nEnd Sub<\/pre>\n<p class=\"zwischen-berschrift-oberer-spaltenrand\">Parameter der Resume-Anweisung<\/p>\n<p>Die <b>Resume<\/b>-Anweisung k&ouml;nnen Sie wie in obigem Beispiel verwenden, um aus der Fehlerroutine in das Programm zur&uuml;ckzuspringen. F&uuml;r die Anweisung gibt es drei unterschiedliche Parameter:<\/p>\n<ul>\n<li class=\"aufz-hlung\"><b>Resume<\/b>: Die Prozedur wird mit dem Befehl fortgesetzt, durch den der Fehler verursacht wurde.<\/li>\n<li class=\"aufz-hlung\"><b>Resume Next<\/b>: Die Prozedur wird mit dem ersten Befehl hinter der Anweisung fortgesetzt, die den Fehler ausgel&ouml;st hat.<\/li>\n<li class=\"aufz-hlung\"><b>Resume &lt;Sprungmarke&gt;<\/b>: Die Prozedur wird an der Stelle fortgesetzt, die durch die angegebene Sprungmarke eingeleitet wird.<\/li>\n<\/ul>\n<h2>Wirkungsbereich der Fehlerbehandlung<\/h2>\n<p>Die Fehlerbehandlung wird durch die <b>On Error<\/b>-Anweisung aktiviert und endet sp&auml;testens mit dem Ende der Prozedur. Dabei gibt es zwei Besonderheiten:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Sie k&ouml;nnen die Fehlerbehandlung auch vor dem Prozedurende mit der Anweisung <b>On Error Goto 0 <\/b>deaktivieren.<\/li>\n<li class=\"aufz-hlung\">Wenn die Prozedur eine weitere Prozedur oder Funktion aufruft, w&auml;hrend die Fehlerbehandlung aktiviert ist, gilt die Fehlerbehandlung auch hier als aktiviert. Das Gleiche gilt auch f&uuml;r weitere Verschachtelungen.<\/li>\n<\/ul>\n<h2>Das Objekt Err<\/h2>\n<p>Die obigen Beispiele verwendeten bereits einige Eigenschaften des Objekts <b>Err<\/b>. 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 <b>Err.Number<\/b>, um die Nummer eines Fehlers abzufragen und entsprechend darauf zu reagieren, und die Eigenschaft <b>Err.Description<\/b>, um die Fehlerbeschreibung unerwarteter Laufzeitfehler auszugeben.<\/p>\n<h2>Unerwartete Laufzeitfehler<\/h2>\n<p>Wenn in einer Prozedur die Fehlerbehandlung aktiviert ist, enth&auml;lt die Prozedur meist auch eine Fehlerbehandlungsroutine, die auf die Behandlung bestimmter Fehler vorbereitet ist. Das ist auch in obigem Beispiel der Fall &#8211; 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 &#8211; etwa beim Beenden der Prozedur &#8211; anzuwenden ist.<\/p>\n<p>Im vorherigen Beispiel wurden Fehler, die nicht die Fehlernummer <b>11 <\/b>hatten, durch eine selbstdefinierte Meldung angezeigt &#8211; zum Beispiel beim Eingeben von Zahlenwerten anstatt Buchstaben (s. Bild 6).<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image037.png\" alt=\"image037.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 6: Eine benutzerdefinierte Fehlermeldung einen f&uuml;r einen unerwarteten Fehler &#8230;<\/span><\/b><\/p>\n<p>Dies ist die einzige M&ouml;glichkeit, den unerwarteten Fehler mit einer Fehlermeldung anzuzeigen und anschlie&szlig;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 (siehe Bild 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.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image013.png\" alt=\"image013.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 7: &#8230; und die gewohnte Access-Fehlermeldung<\/span><\/b><\/p>\n<p>Um den Fehler erneut zu erzeugen, ersetzen Sie die Anweisung im <b>Case Else<\/b>-Teil der Fehlerbehandlung durch die folgenden Anweisungen:<\/p>\n<pre>Dim Fehlernummer As Integer\r\nFehlernummer = Err.Number\r\nErr.Clear\r\nErr.Raise Fehlernummer<\/pre>\n<p>Die erste Anweisung deklariert eine Variable namens Fehlernummer. Die Variable speichert die Nummer des Fehlers, bevor die aktuellen Informationen des Fehlerobjektes <b>Err <\/b>gel&ouml;scht werden. Anschlie&szlig;end erzeugt die Anweisung <b>Err.Raise Fehlernummer <\/b>erneut den Fehler mit der angegebenen Nummer. Tritt nun ein unerwarteter Fehler auf, erscheint die gewohnte Access-Fehlermeldung (s. Bild 7).<\/p>\n<h2>Fehlersuche<\/h2>\n<p>Wenn ein Laufzeitfehler auftritt, kann Access Ihnen eine gro&szlig;e Hilfe beim Finden des Fehlers sein. Wenn Access n&auml;mlich einen Fehler wie beispielsweise in Bild 8). In manchen F&auml;llen k&ouml;nnen Sie das Programm einfach durch einen Klick auf die Schaltfl&auml;che <b>Weiter<\/b> fortsetzen.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image020.png\" alt=\"image020.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 8: Diese Zeile dient als Haltepunkt.<\/span><\/b><\/p>\n<p>Sie k&ouml;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&auml;tigen Sie doch einfach einmal die Schaltfl&auml;che <b>Hilfe<\/b>. Access zeigt dann einen Text an, der m&ouml;gliche Gr&uuml;nde f&uuml;r den eingetretenen Fehler anzeigt.<\/p>\n<h2>Der Unterbrechungsmodus<\/h2>\n<p>Im Unterbrechungsmodus finden Sie in der Symbolleiste von Access drei Schaltfl&auml;chen, die Ihnen im Folgenden helfen werden:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Wenn Sie den Fehler erkannt haben, k&ouml;nnen Sie ihn direkt beheben und durch Bet&auml;tigen der Pfeil-Schaltfl&auml;che mit der Ausf&uuml;hrung des Programms fortfahren.<\/li>\n<li class=\"aufz-hlung\">Die Schaltfl&auml;che mit dem Viereck beendet die Programmausf&uuml;hrung und Access l&ouml;scht alle lokalen und privaten Variablen.<\/li>\n<li class=\"aufz-hlung\">Mit der Schaltfl&auml;che mit dem Pfeil nach links k&ouml;nnen Sie das Programm ebenfalls beenden. Dabei werden alle Variablen gel&ouml;scht.<\/li>\n<\/ul>\n<p>Beim Auffinden logischer Programmfehler k&ouml;nnen Ihnen diese Schaltfl&auml;chen jedoch nicht helfen. Schlie&szlig;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.<\/p>\n<p>In diesem Fall m&uuml;ssen Sie sich selbst auf die Suche machen. Aber auch dabei stellt Access Ihnen einige Hilfsmittel zur Verf&uuml;gung.<\/p>\n<h2>Suchen logischer Programmfehler<\/h2>\n<p>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&ouml;glichen, m&uuml;ssen Sie zun&auml;chst einen Punkt festlegen, an dem die Prozedur angehalten werden soll, um die gew&uuml;nschten Werte abzufragen.<\/p>\n<p>Das Abfragen von aktuellen Variableninhalten ist zwar auch m&ouml;glich, wenn das Programm durch einen Laufzeitfehler in den Unterbrechungsmodus gesetzt wurde, aber Sie k&ouml;nnen den Unterbrechungsmodus auch manuell aktivieren.<\/p>\n<p>Um ein Programm an einer bestimmten Stelle anzuhalten, gehen Sie folgenderma&szlig;en vor:<\/p>\n<ul>\n<li class=\"aufz-hlung\">&Ouml;ffnen Sie die Prozedur im Modulfenster.<\/li>\n<li class=\"aufz-hlung\">Klicken Sie mit der rechten Maustaste auf die gew&uuml;nschte Zeile, um das Kontextmen&uuml; zu &ouml;ffnen.<\/li>\n<li class=\"aufz-hlung\">W&auml;hlen Sie den Men&uuml;befehl <b>Umschalten|Haltepunkt<\/b>.<\/li>\n<\/ul>\n<p>Wenn Sie die Prozedur einmal in der Entwurfsansicht ge&ouml;ffnet haben, geht es auch noch einfacher: Klicken Sie mit der linken Maustaste in H&ouml;he der gew&uuml;nschten Zeile auf den grauen Rand links von der Zeile.<\/p>\n<p>Beide Methoden haben das gleiche Ergebnis: Die Zeile wird rot unterlegt und zus&auml;tzlich durch einen roten Punkt im linken Bereich des Modulfensters markiert (s. Bild 8). Um einen Haltepunkt wieder zu entfernen, klicken Sie entweder auf den roten Punkt oder w&auml;hlen Sie &uuml;ber das Kontextmen&uuml; der Zeile erneut den Befehl <b>Umschalten|Haltepunkt <\/b>aus.<\/p>\n<p>Vorteilhaft ist es, wenn Sie ungef&auml;hr absch&auml;tzen k&ouml;nnen, in welcher Prozedur und an welcher Stelle der Fehler ungef&auml;hr auftritt. Sie k&ouml;nnen dann an der entsprechenden Stelle einen Haltepunkt setzen und von dort aus das Programm in kleinen Schritten untersuchen. <\/p>\n<p>Wenn Sie das Programm nun starten, h&auml;lt es an der angegebenen Stelle an. Access zeigt im Modulfenster die aktuelle Zeile an. Hier haben Sie nun folgende M&ouml;glichkeiten, die Sie beispielsweise &uuml;ber das Men&uuml; <b>Debuggen <\/b>aufrufen k&ouml;nnen (s. Bild 9):<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image039.png\" alt=\"image039.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 9: Men&uuml; mit weiteren Debug-Befehlen<\/span><\/b><\/p>\n<ul>\n<li class=\"aufz-hlung\"><b>Haltepunkt ein\/aus<\/b>: Entfernen des Haltepunktes in der aktuellen Zeile<\/li>\n<li class=\"aufz-hlung\"><b>Einzelschritt<\/b>: F&uuml;hrt einen Einzelschritt aus, d. h., dass Access die aktuell markierte Anweisung ausf&uuml;hrt.<\/li>\n<li class=\"aufz-hlung\"><b>Prozedurschritt<\/b>: F&uuml;hrt einen Prozedurschritt aus. Wenn Sie diese Schaltfl&auml;che innerhalb der aktuellen Prozedur verwenden, wird jeder Befehl als Einzelschritt ausgef&uuml;hrt. Erst das Aufrufen eines Befehls, der eine weitere Prozedur aufruft, bewirkt das Ausf&uuml;hren der kompletten &#8222;Unterprozedur&#8220; ohne weitere Einzelschritte.<\/li>\n<li class=\"aufz-hlung\"><b>Prozedur abschlie&szlig;en<\/b>: F&uuml;hrt einen R&uuml;cksprung aus. Dabei werden die verbleibenden Anweisungen der aktuellen Prozedur ausgef&uuml;hrt und es wird zur aufrufenden Prozedur zur&uuml;ckgesprungen, wo dann erneut angehalten wird.<\/li>\n<li class=\"aufz-hlung\">Men&uuml; <b>Anzeige|Aufrufeliste<\/b>: Zeigt die Namen der Datenbank, des Moduls sowie der Prozedur der aktuellen und der aufrufenden Prozedur bis zur obersten Ebene an (s. Bild 10).<\/li>\n<\/ul>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image028.png\" alt=\"image028.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 10: Die Aufrufreihenfolge einer Prozedur<\/span><\/b><\/p>\n<h2>Abfrage von Variablen im Unterbrechungsmodus<\/h2>\n<p>Wenn Sie sich im Unterbrechungsmodus befinden und die Anwendung Schritt f&uuml;r Schritt durchlaufen, um anhand der Variablenwerte zu den unterschiedlichen Zeitpunkten logische Fehler ausfindig zu machen, haben Sie mehrere M&ouml;glichkeiten, die entsprechenden Werte anzuzeigen.<\/p>\n<p>Die erste M&ouml;glichkeit besteht darin, den Mauszeiger im Unterbrechungsfenster &uuml;ber der gew&uuml;nschten Variablen zu positionieren. Der Wert wird dann per Tooltip-Text angezeigt (s. Bild 11).<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image030.png\" alt=\"image030.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 11: Variablenwerte im Codefenster <\/span><\/b><\/p>\n<h2>Abfrage von Variablen im Testfenster<\/h2>\n<p>Das Testfenster dient nicht nur dem Starten von Prozeduren, sondern kann auch zur Ermittlung und Ausgabe von Variablenwerten verwendet werden.<\/p>\n<p>Die einfachste M&ouml;glichkeit, einen Wert im Testfenster auszugeben, ist der Befehl <b>Debug.Print<\/b>. Wenn Sie diesen Befehl gefolgt von einem Ausdruck in eine Prozedur einf&uuml;gen, gibt Access den angegebenen Ausdruck im Testfenster aus.<\/p>\n<p>W&auml;hrend sich eine Prozedur im Unterbrechungsmodus befindet, k&ouml;nnen Sie &uuml;ber das Testfenster die aktuellen Variablenwerte einzeln ausgeben lassen und sie bei Bedarf &auml;ndern.<\/p>\n<p>Die manuelle Ausgabe der Variablen ist aber in den meisten F&auml;llen nicht erforderlich, da dies in der oberen H&auml;lfte des Testfensters, dem so genannten Lokalbereich, automatisch geschieht. Wenn Sie beispielsweise einen Haltepunkt bei der Ausgabe des Ergebnisses der Prozedur <b>Division <\/b>setzen, sieht das Testfenster wie in Bild 12 aus.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image032.png\" alt=\"image032.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 12: Anzeige von Variablen im Testfenster<\/span><\/b><\/p>\n<p>Noch komfortabler ist die kontrollierte &Uuml;berwachung von Variablen. Im Gegensatz zur Ausgabe einer Variablen via VBA-Anweisung oder im lokalen Teil des Testfensters k&ouml;nnen Sie hier gezielt Variablen festlegen, die w&auml;hrend der Laufzeit angezeigt werden. Um eine Variable zu &uuml;berwachen, gehen Sie folgenderma&szlig;en vor:<\/p>\n<ul>\n<li class=\"aufz-hlung\">Klicken Sie mit der rechten Maustaste auf die gew&uuml;nschte Variable, um das Kontextmen&uuml; anzuzeigen.<\/li>\n<li class=\"aufz-hlung\">W&auml;hlen Sie den Befehl <b>&Uuml;berwachung hinzuf&uuml;gen <\/b>aus.<\/li>\n<li class=\"aufz-hlung\">Passen Sie die Parameter im Dialog <b>&Uuml;berwachung hinzuf&uuml;gen <\/b>an.<\/li>\n<\/ul>\n<p>Access f&uuml;gt den Namen der Variablen automatisch in das Textfeld Ausdruck ein (s. Bild 13). Im Bereich <b>Kontext<\/b> k&ouml;nnen Sie festlegen, in welchem Bereich die Variable &uuml;berwacht werden soll. Dabei gilt: Die &Uuml;berwachung einer Variablen kostet immer Ressourcen. Sie sollten deshalb den maximal ben&ouml;tigten Bereich ausw&auml;hlen &#8211; also beispielsweise nur Prozeduren, in denen Ver&auml;nderungen an der Variablen vorgenommen werden. Im Bereich &Uuml;berwachungsart k&ouml;nnen Sie festlegen, ob einfach nur der aktuelle Wert der Variablen ausgegeben oder ob beim Erreichen bestimmter Werte die Prozedur angehalten werden soll.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image034.png\" alt=\"image034.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 13: Der Dialog &Uuml;berwachung hinzuf&uuml;gen<\/span><\/b><\/p>\n<p>So k&ouml;nnen Sie beispielsweise im Ausdruck einen Vergleichsausdruck angeben, bei dessen Eintreten die Prozedur angehalten wird, oder Sie w&auml;hlen die dritte Option und halten damit die Prozedur an, sobald der Wert der Variablen ge&auml;ndert wird. <\/p>\n<p>Um die &uuml;berwachten Werte betrachten zu k&ouml;nnen, m&uuml;ssen Sie im oberen Bereich des Testfensters das Register <b>&Uuml;berwachung aktivieren <\/b>(s. Bild 14). Beachten Sie, dass die Anzeige eines &Uuml;berwachungsausdrucks nur im Einzelschrittmodus funktioniert, w&auml;hrend die anderen beiden Optionen f&uuml;r den Laufzeiteinsatz vorgesehen sind.<\/p>\n<p><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2000_01\/FehlersucheUndBehandlung-web-images\/image036.png\" alt=\"image036.png\" \/><\/p>\n<p><b><span style=\"color:darkgrey\">Bild 14: &Uuml;berwachung einer Variablen<\/span><\/b><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Wenn Sie bereits einmal Datenbankanwendungen mit VBA-Funktionen und -Prozeduren entwickelt haben, kennen Sie bereits das Vergn&uuml;gen, sich mit dem Auffinden und Beheben der unterschiedlichsten Fehler herumzuschlagen &#8211; 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&ouml;nnen, wie man die Fehler findet und sie schlie&szlig;lich behebt. Dabei lernen Sie auch die unterschiedlichen M&ouml;glichkeiten der Fehlersuche kennen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66012000,662000,44000025],"tags":[],"class_list":["post-55000001","post","type-post","status-publish","format-standard","hentry","category-66012000","category-662000","category-VBA_und_Programmiertechniken"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v20.9 (Yoast SEO v27.5) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>Fehlerbehandlung unter VBA und Access<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Fehlersuche und -behandlung mit Access\" \/>\n<meta property=\"og:description\" content=\"Wenn Sie bereits einmal Datenbankanwendungen mit VBA-Funktionen und -Prozeduren entwickelt haben, kennen Sie bereits das Vergn&uuml;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&ouml;nnen, wie man die Fehler findet und sie schlie&szlig;lich behebt. Dabei lernen Sie auch die unterschiedlichen M&ouml;glichkeiten der Fehlersuche kennen.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2021-03-22T13:09:19+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg02.met.vgwort.de\/na\/e6ee7d7787c74452924c654ed6c43b6b\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"18\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Fehlersuche und -behandlung mit Access\",\"datePublished\":\"2021-03-22T13:09:19+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/\"},\"wordCount\":3322,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/e6ee7d7787c74452924c654ed6c43b6b\",\"articleSection\":[\"1\\\/2000\",\"2000\",\"VBA und Programmiertechniken\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/\",\"name\":\"Fehlerbehandlung unter VBA und Access\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/e6ee7d7787c74452924c654ed6c43b6b\",\"datePublished\":\"2021-03-22T13:09:19+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/e6ee7d7787c74452924c654ed6c43b6b\",\"contentUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/e6ee7d7787c74452924c654ed6c43b6b\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlersuche_und_behandlung_mit_Access\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Fehlersuche und -behandlung mit Access\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Fehlerbehandlung unter VBA und Access","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/","og_locale":"de_DE","og_type":"article","og_title":"Fehlersuche und -behandlung mit Access","og_description":"Wenn Sie bereits einmal Datenbankanwendungen mit VBA-Funktionen und -Prozeduren entwickelt haben, kennen Sie bereits das Vergn&uuml;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&ouml;nnen, wie man die Fehler findet und sie schlie&szlig;lich behebt. Dabei lernen Sie auch die unterschiedlichen M&ouml;glichkeiten der Fehlersuche kennen.","og_url":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/","og_site_name":"Access im Unternehmen","article_published_time":"2021-03-22T13:09:19+00:00","og_image":[{"url":"http:\/\/vg02.met.vgwort.de\/na\/e6ee7d7787c74452924c654ed6c43b6b","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"18\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Fehlersuche und -behandlung mit Access","datePublished":"2021-03-22T13:09:19+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/"},"wordCount":3322,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/#primaryimage"},"thumbnailUrl":"http:\/\/vg02.met.vgwort.de\/na\/e6ee7d7787c74452924c654ed6c43b6b","articleSection":["1\/2000","2000","VBA und Programmiertechniken"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/","url":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/","name":"Fehlerbehandlung unter VBA und Access","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/#primaryimage"},"thumbnailUrl":"http:\/\/vg02.met.vgwort.de\/na\/e6ee7d7787c74452924c654ed6c43b6b","datePublished":"2021-03-22T13:09:19+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/#primaryimage","url":"http:\/\/vg02.met.vgwort.de\/na\/e6ee7d7787c74452924c654ed6c43b6b","contentUrl":"http:\/\/vg02.met.vgwort.de\/na\/e6ee7d7787c74452924c654ed6c43b6b"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Fehlersuche_und_behandlung_mit_Access\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Fehlersuche und -behandlung mit Access"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000001","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000001"}],"version-history":[{"count":5,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000001\/revisions"}],"predecessor-version":[{"id":88072350,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000001\/revisions\/88072350"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000001"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000001"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000001"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}