Im Beitrag „Fehlerbehandlung per VBA hinzufügen“ (www.access-im-unternehmen.de\/1514) zeigen wir, wie man Fehlerinformationen direkt per VBA in eine Fehlertabelle schreibt, um diese später zu kontrollieren. Wenn man nun als Entwickler eine fehlerhafte Datei mit einigen protokollierten Fehlern vom Benutzer erhält, möchte man vielleicht direkt die fehlerhaften Stellen einsehen. Dazu muss man allerdings erst nachsehen, welches Modul, welche Prozedur und welche Zeile betroffen sind, dann die entsprechende Stelle im VBA-Editor suchen und so weiter. Bei einer umfangreichen Datenbank kann das sehr mühselig werden, vor allem wenn man sich von Fehler zu Fehler hangelt. Deshalb liefern wir in diesem Beitrag noch eine praktische Ergänzung, wenn Sie ohnehin schon eine Tabelle wie aus dem oben genannten Beitrag zum Speichern der Fehler verwenden: Ein Formular, dass diese Fehler anzeigt und mit dem Sie per Mausklick auf einen Fehler direkt die entsprechende Stelle im VBA-Editor anzeigen können.<\/b><\/p>\n
Ziel des Beitrags<\/h2>\n
Ziel dieses Beitrags ist es, die Inhalte der Tabelle aus Bild 1 in einem Unterformular in der Datenblattansicht anzuzeigen, um diese dann zu selektieren und die Stelle zu der Fehlermeldung direkt im Quellcode anzuzeigen.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2024_05\/pic_1518_001.png\")
<\/p>\n
Bild 1: Die Inhalte dieser Tabelle sollen im Formular angezeigt werden<\/span><\/b><\/p>\n Dazu legen wir zunächst ein Unterformular an, dem wir als Datensatzquelle die Tabelle tblErrors <\/b>zuweisen. Wir ziehen alle Felder dieser Tabelle bis auf das Feld ID <\/b>in den Detailbereich des Formularentwurfs und stellen die Eigenschaft Standardansicht <\/b>auf Datenblatt <\/b>ein.<\/p>\n Dann schließen wir das Formular und speichern es unter dem Namen sfmErrors<\/b>. Anschließend legen wir das Hauptformular an. Diesem fügen wir das Unterformular sfmErrors <\/b>per Drag and Drop aus dem Navigationsbereich hinzu. Damit es seine Größe anpasst, wenn wir die Größe des Formulars ändern, stellen wir die beiden Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>auf den Wert Beide <\/b>ein. Die beiden automatisch geänderten entsprechenden Eigenschaften des Bezeichnungsfeldes stellen wir wieder auf die ursprünglichen Werte Links <\/b>und Oben <\/b>ein.<\/p>\n Außerdem stellen wir die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>für das Hauptformular auf Nein <\/b>ein.<\/p>\n Schließlich benötigen wir zumindest eine Schaltfläche, mit der wir den aktuell markierten Fehler im VBA-Editor anzeigen können. Dieser geben wir den Namen cmdShowInVBAEditor<\/b> und hinterlegen dann eine Ereignisprozedur für das Ereignis Beim Klicken<\/b>.<\/p>\n Anschließend sieht das Formular in der Entwurfsansicht wie in Bild 2 aus.<\/p>\n Bild 2: Das Formular frmErrors mit Unterformular<\/span><\/b><\/p>\n Bevor wir diese füllen, fügen wir, sofern noch nicht vorhanden, noch einen Verweis auf die Bibliothek Microsoft Visual Basic Extensibility 5.3 Object Library <\/b>hinzu. Diese liefert das Objektmodell, mit dem wir den VBA-Editor programmieren können.<\/p>\n Anschließend füllen wir die Ereignisprozedur cmdShowInVBAEditor_Click<\/b> mit der Prozedur aus Listing 1.<\/p>\n Listing 1: Prozedur zum Anzeigen des Codes zu einer Fehlermeldung<\/span><\/b><\/p>\n Die Prozedur liest zuerst die relevanten Informationen für den aktuell markierten Datensatz aus und trägt diese in die Variablen strErrorModule<\/b>, strErrorProcedure <\/b>und lngErrorLine <\/b>ein.<\/p>\n Dann erstellt sie einen Verweis auf das aktuelle VBA-Projekt und holt sich ebenfalls einen Verweis auf das VBComponent<\/b>-Objekt mit dem Namen aus strErrorModule <\/b>sowie auf dessen CodeModule<\/b>-Element.<\/p>\n Dann beginnen wir bereits, die Zeile zu finden, die den in der Tabelle tblError <\/b>enthaltenen Fehler ausgelöst hat. Dazu durchlaufen wir in einer For…Next<\/b>-Schleife alle Zeilen des Moduls von der ersten Zeile bis zu der mit objCodeModule.CountOfLines <\/b>ermittelten letzten Zeile.<\/p>\n Dabei ermitteln wir mit der Lines<\/b>-Funktion die aktuelle Zeile und schreiben diese in die Variable strLine<\/b>. Außerdem ermitteln wir jeweils die Prozedur, zu der die aktuelle Zeile gehört.<\/p>\n Das erledigen wir mit der Funktion ProcOfLine<\/b>, der wir als ersten Parameter die Zeilennummer und als zweiten die leere Variable intProcType <\/b>übergeben (den damit zurückgelieferten Wert benötigen wir nicht, aber es ist ein Pflichtparameter).<\/p>\n Wir prüfen dann für jede Zeile, ob die Nummer der fehlerhaften Zeile mit der Zeilennummer der aktuellen Zeile übereinstimmt. Diese können wir glücklicherweise einfach mit der Val<\/b>-Funktion ermitteln, die alle führenden Ziffern einer Zeichenfolge liefert – in diesem Fall genau die Zeilennummerierung. Wenn wir uns in der richtigen Prozedur befinden und auch noch die Zeilennummer stimmt, verlassen wir die For…Next<\/b>-Schleife und behalten so den aktuellen Wert der Laufvariablen lngLine <\/b>bei.<\/p>\n Nun folgt eine Maßnahme für den Fall, dass die fehlerhafte Anweisung über mehr als eine Zeile geht. Wir speichern lngLine <\/b>in lngLastLine <\/b>und prüfen in der Bedingung einer Do While<\/b>-Schleife, ob das letzte Zeichen der Zeile lngLastLine <\/b>der Unterstrich ist (_<\/b>).<\/p>\n Falls ja, erhöhen wir lngLastLine <\/b>um 1<\/b>. Das machen wir solange, bis die folgende Zeile nicht mit dem Unterstrich endet. lngLine <\/b>enthält dann die Nummer der ersten Zeile und lngLastLine <\/b>die Nummer der letzten Zeile der Anweisung.<\/p>\n Nun referenzieren wir das CodePane<\/b>-Element des CodeModule<\/b>-Objekts und rufen dessen SetSelection<\/b>-Methode auf. Hier übergeben wir für den Parameter StartLine <\/b>den Wert aus lngLine <\/b>und für EndLine<\/b> den Wert aus lngLastLine<\/b>.<\/p>\n Außerdem stellen wir den Parameter StartColumn <\/b>auf den Wert 1 <\/b>ein und EndColumn <\/b>auf 999<\/b>. Die Show<\/b>-Methode zeigt schließlich das CodePane<\/b>-Objekt an, was dem Codefenster entspricht. Das Ergebnis für eine Beispielcodezeile sieht wie in Bild 3 aus.<\/p>\nFormular und Unterformular erstellen<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2024_05\/pic_1518_002.png\")
<\/p>\nVerweis zum Programmieren des VBA-Editors<\/h2>\n
Prozedur zum Anzeigen und Markieren einer Zeile<\/h2>\n
Private Sub <\/span>cmdErrors_Click()\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>objCodePane As <\/span>VBIDE.CodePane\r\n Dim <\/span>strErrorModule As String<\/span>\r\n Dim <\/span>strErrorProcedure As String<\/span>\r\n Dim <\/span>lngErrorLine As String<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>lngLastLine As Long<\/span>\r\n Dim <\/span>strLine As String<\/span>\r\n Dim <\/span>strProcedure As String<\/span>\r\n Dim <\/span>intProcType As <\/span>vbext_ProcKind\r\n \r\n With<\/span> Me!sfmErrors.Form\r\n strErrorModule = !ErrorModule\r\n strErrorProcedure = !Errorprocedure\r\n lngErrorLine = !ErrorLine\r\n End With<\/span>\r\n \r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strErrorModule)\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n \r\n For lngLine = 1 To objCodeModule.CountOfLines\r\n strLine = objCodeModule.Lines(lngLine, 1)\r\n Debug.Print<\/span> lngLine, Val(strLine), strLine\r\n strProcedure = objCodeModule.ProcOfLine(lngLine, intProcType)\r\n If <\/span>strProcedure = strErrorProcedure And lngErrorLine = Val(strLine) Then<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> lngLine\r\n \r\n Set<\/span> objCodePane = objCodeModule.CodePane\r\n \r\n lngLastLine = lngLine\r\n Do While<\/span> right(Trim<\/span>(objCodeModule.Lines(lngLastLine, 1)), 1) = \"_\"\r\n lngLastLine = lngLastLine + 1\r\n Loop<\/span>\r\n \r\n objCodePane.SetSelection lngLine, 1, lngLastLine, 999\r\n objCodePane.Show\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2024_05\/pic_1518_003.png\")
<\/p>\n