<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
Wer hat sich nicht schon einmal die eine oder andere, vielleicht ganz individuelle Erweiterung der Entwicklungsumgebung von Access gewünscht Klar, wie man sich einen Assistenten für bestimmte Aufgaben bastelt, ist in der Fachliteratur hinlänglich erklärt, aber den VBA-Editor mit zusätzlichen Funktionen versehen Dieser Beitrag zeigt, wie Sie mit etwas Fremdhilfe von VB eine .dll-Datei entwickeln, die viele Wünsche erfüllen kann.<\/b><\/p>\n
Wahrscheinlich verfügt nicht jeder Leser dieses Beitrags über das Microsoft Visual Studio. Das hätte den Nachteil, dass er nicht selbst Lösungen wie diese oder ähnliche erstellen kann – was einerseits sehr schade ist, denn wer die hier vorgestellte Technik einmal kennt, der möchte vermutlich für einige immer wiederkehrende Aufgaben eine automatische Lösung erstellen. Andererseits kommen Sie auch als Nicht-Visual Studio-Anwender in den Genuss der hier vorgestellten Lösung, da diese als .dll-Datei auf der Heft-CD vorliegt.<\/p>\n
Um die fertige DLL im VBA-Editor verwenden zu können, müssen Sie diese zunächst registrieren. Dazu kopieren Sie die DLL in einen Ordner Ihrer Wahl (am besten zu den anderen DLLs im Windows-Verzeichnis unter System32).<\/p>\n
Anschließend rufen Sie im Ausführen-Dialog (Start ( Ausführen) die Anweisung regsvr32 mit dem kompletten Pfad der DLL als Parameter auf. Beim nächsten Start von Access und der VBA-Entwicklungsumgebung stehen die Funktionen dann zur Verfügung.<\/p>\n
Die DLL arbeitet mit Access ab Version 2000 zusammen. <\/p>\n
Im Beitrag Professionelle Fehlerbehandlung in dieser Ausgabe von Access im Unternehmen finden Sie eine Fehlerbehandlung, die bei jedem aufgetretenen Fehler einen Eintrag in eine Datei vornimmt und dort die Fehlernummer, die Beschreibung, das Modul und die Prozedur, in der der Fehler auftritt, sowie die entsprechende Zeilennummer einträgt.<\/p>\n
Dazu muss allerdings erst einmal eine Zeilennummer vorhanden sein; Access trägt diese nicht automatisch in eine Prozedur ein oder ermittelt diese wie andere Programmiersprachen. Wer schon einmal eine etwas umfangreichere Anwendung entwickelt hat, kann sich ungefähr vorstellen, wie viele Zeilen Code eine solche Anwendung enthält.<\/p>\n
Der Aufwand, diese von Hand zu nummerieren, ist unverhältnismäßig groß. Hinzu kommt, dass – egal wie groß man die Abstände zwischen den einzelnen Zahlen wählt – garantiert irgendwann so viele Zeilen hinzukommen, dass man alles erneut nummerieren muss. Da kommt eine Funktion zum automatischen Nummerieren von Modulen doch gerade recht.<\/p>\n
Wenn Sie die DLL ordnungsgemäß registriert haben, erscheint beim öffnen der VBA-Entwicklungsumgebung eine neue Menüleiste mit drei Schaltflächen (s. Abb. 1).<\/p>\n
![](\"..\/fileadmin\/_temp_\/{01EF284D-8E62-4FDF-8C3C-20710CD56061}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 1: Zeilen nummerieren per Knopfdruck<\/b><\/p>\n
![](\"..\/fileadmin\/_temp_\/{01EF284D-8E62-4FDF-8C3C-20710CD56061}\/pic002.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 2: Hinzufügen einer Fehlerbehandlung<\/b><\/p>\n
Mit einem Klick auf die Schaltfläche Modul nummerieren fügen Sie dem aktuellen Modul eine Nummerierung hinzu. Um diese wieder zu entfernen, klicken Sie einfach auf die Schaltfläche Modul entnummerieren.<\/p>\n
Fehlerbehandlungen haben immer das gleiche Grundgerüst. Der VBA-Editor bietet auch eine eingebaute Funktion an, um eine rudimentäre Fehlerbehandlung zu integrieren, aber um die im Beitrag Professionelle Fehlerbehandlung vorgestellte Fehlerbehandlung zu verwenden, bedarf es ein paar Zeilen mehr.<\/p>\n
Um eine Fehlerbehandlung in eine beliebige Prozedur zu integrieren, öffnen Sie einfach das gewünschte Modul, platzieren die Einfügemarke über der entsprechenden Prozedur und klicken auf die Schaltfläche Fehlerbehandlung hinzufügen. Das Ergebnis sieht beispielsweise wie in Abb. 2 aus.<\/p>\n
Nur den wenigsten Anwendern dürfte bekannt sein, dass man mit einem VB-Programm die Entwicklungsumgebung von Access, nachfolgend kurz VBA-Editor genannt, um eigene Funktionen erweitern kann. Das VB-Programm nistet sich – einmal registriert – an der gewünschten Stelle im VBA-Editor ein und stellt dort fortan seine Funktionen zur Verfügung. Im vorliegenden Fall sollen die entsprechenden Funktionen über eine spezielle Menüleiste aufgerufen werden.<\/p>\n
Um die .dll-Datei zu erstellen, benötigen Sie – wie oben erwähnt – Microsoft Visual Studio 6.0. Nach dem Start des Visual Studios bietet es Ihnen verschiedene Möglichkeiten zum Erstellen eines neuen Projekts an. Wählen Sie dort den Eintrag ActiveX-DLL aus.<\/p>\n
Das nun erscheinende Bild mag Access-Entwicklern teilweise bekannt vorkommen, da es prinzipiell die gleichen Elemente wie der VBA-Editor enthält. Der wesentliche Unterschied ist, dass die Benutzeroberfläche der zu erstellenden Anwendungen ebenfalls hier und nicht in einer separaten Umgebung wie unter Access erzeugt werden kann.<\/p>\n
Damit Sie das Projekt später identifizieren können, stellen Sie nun einige Eigenschaften (Menüeintrag Projekt\/Eigenschaften von Projekt1…) wie in Abb. 3 ein. Entfernen Sie dann das Klassenmodul Class1 aus dem Objektexplorer (zu aktivieren mit Strg + R). Anschließend speichern Sie das Projekt unter dem Namen VBAExtensions.<\/p>\n
öffnen Sie nun den Dialog Komponenten (Menüeintrag Projekt\/Komponenten) und aktivieren Sie auf der Registerseite Designer den Eintrag Addin Class. <\/p>\n
![](\"..\/fileadmin\/_temp_\/{01EF284D-8E62-4FDF-8C3C-20710CD56061}\/pic003.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 3: Eigenschaften des neuen Projekts<\/b><\/p>\n
![](\"..\/fileadmin\/_temp_\/{01EF284D-8E62-4FDF-8C3C-20710CD56061}\/pic004.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 4: Einstellungen des AddInDesigners<\/b><\/p>\n
![](\"..\/fileadmin\/_temp_\/{01EF284D-8E62-4FDF-8C3C-20710CD56061}\/pic005.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 5: Die letzten beiden Referenzen <\/b><\/p>\n
Falls dadurch nicht automatisch eine neue Addin Class zu dem Projekt hinzugefügt wird, holen Sie das nach: Wählen Sie aus dem Kontextmenü des Eintrags VBAExtensions (VBAExtensions.vbp) im Projektexplorer den Eintrag Hinzufügen ( Addin Class aus.<\/p>\n
Neben dem neuen Eintrag im Projektexplorer erscheint ein Dialog mit den Eigenschaften der neuen AddIn-Klasse. Ergänzen Sie die Eigenschaften wie in Abb. 4.<\/p>\n
Stellen Sie außerdem im Eigenschaftsfenster des AddIn den Wert der Eigenschaft Public auf True ein. Die nachfolgende Meldung können Sie getrost bejahen.<\/p>\n
Anschließend geben Sie dem Projekt noch die benötigten Referenzen mit auf den Weg. Im vorliegenden Fall benötigen Sie eine Referenz auf die Microsoft Office x.0 Object Library in der Version, die auf dem Zielrechner zum Einsatz kommt, sowie die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 (s. Abb. 5).<\/p>\n
Nachfolgend verwenden wir das Objektmodell des Microsoft Office Visual Basic Editors. Detaillierte Informationen finden Sie unter folgender Internetadresse (ohne Zeilenumbrüche): http:\/\/msdn.microsoft.com\/library\/default.aspurl=\/library\/en-us\/dnofftalk\/html\/office07042002.asp <\/p>\n
Schließlich fügen Sie dem Projekt noch ein neues Modul hinzu, das lediglich eine Zeile enthält:<\/p>\n
Public oVBE As VBIDE.VBE<\/p>\n
Damit setzen Sie eine Referenz auf das oberste Objekt des entsprechenden Objektmodells und können darüber auf die Elemente des VBA-Editors zugreifen.<\/p>\n
Um die DLL zu testen, folgt nun der übliche „Hello World“-Test. öffnen Sie das Modul des AddInDesigner1 per Kontextmenü (Eintrag Code anzeigen). Wählen Sie aus dem linken Kombinationsfeld den Eintrag AddinInstance aus und es erscheint automatisch eine Ereignisprozedur, die Sie wie in Quellcode 1 ergänzen.<\/p>\n
Private Sub AddinInstance_OnConnection(ByVal Application As Object, _ ByVal ConnectMode As AddInDesignerObjects.ext_ConnectMode, _ ByVal AddInInst As Object, custom() As Variant)\n Set objVBAIDE = Application\n MsgBox \"Hello World\"\nEnd Sub<\/pre>\nQuellcode 1<\/b><\/p>\n
Private cbbNummerieren As CommandBarButton\nPrivate WithEvents evtNummerieren As CommandBarEvents\nPrivate Sub AddinInstance_OnConnection(ByVal Application As Object, _ ByVal ConnectMode As AddInDesignerObjects.ext_ConnectMode, _ ByVal AddInInst As Object, custom() As Variant)\n Set oVBE = Application\n Dim cbr As CommandBar\n Set cbr = oVBE.CommandBars.Add(\"VBAExtensions\", Position:=msoBarTop, _ Temporary:=True)\n cbr.Visible = True\n Set cbbNummerieren = cbr.Controls.Add(msoControlButton, Temporary:=True)\n cbbNummerieren.Style = msoButtonIconAndCaption\n cbbNummerieren.FaceId = 11\n cbbNummerieren.Caption = \"Modul nummerieren\"\n Set evtNummerieren = oVBE.Events.CommandBarEvents(cbbNummerieren)\nEnd Sub<\/pre>\nQuellcode 2<\/b><\/p>\n
Kompilieren Sie das Projekt nun über den Menüeintrag Datei\/VBAExtensions.dll erstellen… und probieren Sie die DLL aus, indem Sie eine Access-Datenbank öffnen und mit Strg + G den VBA-Editor aktivieren. Wenn das gewünschte Meldungsfenster erscheint, haben Sie bisher alles richtig gemacht – ansonsten überprüfen Sie nochmals die vorherigen Schritte.<\/p>\n
Hinweis<\/h3>\n
Um während der Entwicklung die Fortschritte mitzuverfolgen und gegebenenfalls den Code zu debuggen, setzen Sie die gewünschten Haltepunkte und starten das Projekt per F5. Das anschließende öffnen von Access und Aufrufen des VBA-Editors verwendet dann das Projekt wie die richtige DLL. <\/p>\n
Um die drei nachfolgend vorgestellten Funktionen im VBA-Editor starten zu können, benötigen Sie eine entsprechende Menüleiste mit drei Schaltflächen.<\/p>\n
Der übersicht halber enthält Quellcode 2 nur die Anweisungen für die Erstellung der ersten Schaltfläche mit der Beschriftung Modul nummerieren.<\/p>\n
Die beiden ersten Zeilen des Moduls enthalten Deklarationen einer Objektvariablen für die Schaltfläche sowie die Deklaration der Ereignisse für die enthaltenen Schaltflächen. <\/p>\n
Die Prozedur, die soeben noch den „Hello World“-Test enthielt, bestücken Sie nun wie in Quellcode 2. Die Prozedur erstellt zunächst eine neue Menüleiste mit dem Namen VBAExtensions, die nach dem Setzen der Visible-Eigenschaft auf den Wert True direkt unter den anderen Menüleisten erscheint und mit dem Schließen des VBA-Editors wieder verschwindet.<\/p>\n
Anschließend fügt die Prozedur der Menüleiste eine Schaltfläche mit der Beschriftung Modul nummerieren hinzu und stellt das im Modulkopf deklarierte Objekt evtNummerieren so ein, dass es auf die Ereignisse der soeben angelegten Schaltfläche reagiert.<\/p>\n
Sie müssen nun nur noch die entsprechende Ereigniseigenschaft für die neue Schaltfläche anlegen. Behilflich ist Ihnen dabei der Editor: Im linken Kombinationsfeld hat er mittlerweile einen Eintrag namens evtNummerieren hinzugefügt, dessen Auswahl automatisch eine Ereigniseigenschaft anlegt. Ergänzen Sie diese wie in folgendem Beispiel und sagen Sie das zweite Mal in diesem Beitrag „Hello World“:<\/p>\n
Private Sub evtNummerieren_Click(ByVal _ CommandBarControl As Object, _ handled As Boolean, CancelDefault _ As Boolean)\n MsgBox \"Hello World\"\nEnd Sub<\/pre>\nAn dieser Stelle führt das öffnen von Access und dem VBA-Editor zum Bild aus Abb. 6.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 6: Die neue Menüleiste inklusive Schaltfläche<\/b><\/p>\n
Hinweis<\/h3>\n
Wenn Sie das Projekt mit F5 starten, anstatt direkt die DLL zu erzeugen, erscheint nach dem Klicken auf die neue Schaltfläche im VBA-Editor das Meldungsfenster im Visual Studio. Nicht, dass Sie sich wundern, wenn nach dem ersten Probeklick gar nichts mehr geht – wechseln Sie einfach zum Visual Studio und schließen Sie das Meldungsfenster. <\/p>\n
Für weitere Schaltflächen benötigen Sie jeweils die beiden Deklarationsanweisungen aus dem Kopf des Moduls – natürlich mit entsprechend angepassten Bezeichnungen – sowie eine angepasste Kopie der fünften bis neunten Zeile der Prozedur AddinInstance_OnConnection für die jede Schaltfläche.<\/p>\n
Selbstverständlich müssen Sie für eine sinnvolle Funktion noch die Anweisung zum Anzeigen des Meldungsfensters durch entsprechenden Code ersetzen. Und wie dieser aussieht, erfahren Sie in den folgenden beiden Kapiteln.<\/p>\n
Bevor man eine Routine zum Nummerieren der Zeilen eines Moduls entwickeln kann, muss man genau wissen, welche Zeilen nummeriert werden sollen und welche nicht – besser gesagt: welche Zeilen überhaupt nummeriert werden dürfen oder müssen.<\/p>\n
Genau genommen werden für die Verwendung mit der Fehlerbehandlung nur die Zeilen benötigt, in denen auch Fehler auftreten können, also solche, die ausführbaren Code enthalten. Herauszufinden, welche Zeile ausführbaren Code enthält, könnte sich aber als sehr schwierig erweisen. Also vielleicht lieber den Hebel am anderen Ende ansetzen und testen, welchen Zeilen der Compiler eine Zeilennummer gönnt <\/p>\n
Zum Glück probieren Autoren manchmal einiges aus, bevor sie einen Beitrag schreiben. In dem Fall hilft der goldene Mittelweg: Ausführbaren Code findet man nur innerhalb von Properties, Subs und Functions. Innerhalb dieser Strukturen gibt es ein paar Stellen, an denen Nummerierungen nicht erlaubt sind – beispielsweise bei Fortsetzungen umbrochener Zeilen oder in der ersten Zeile eines Select Case-Konstrukts.<\/p>\n
Die Prozedur aus Quellcode 3 wird dem gerecht. Sie überprüft zunächst, ob überhaupt ein Modul aktiviert ist (If oVBE.ActivecodePane Is Nothing) und gibt anderenfalls eine entsprechende Meldung aus. Liegt ein Modul vor, erzeugt die Prozedur mit der Objektvariablen cdPane einen Verweis darauf; ein weiterer Verweis namens mdl dient im Anschluss dem Zugriff auf das enthaltene Modul.<\/p>\n
Private Sub evtNummerieren_Click(ByVal CommandBarControl As Object, _ handled As Boolean, CancelDefault As Boolean)\n Dim cdPane As VBIDE.CodePane\n Dim mdl As VBIDE.CodeModule\n Dim bolNummerieren As Boolean\n Dim bolJetztNicht As Boolean\n Dim bolNaechsteNicht As Boolean\n Dim strZeile As String\n Dim i As Integer\n If oVBE.ActiveCodePane Is Nothing Then\n MsgBox \"Bitte öffnen Sie zunächst das gewünschte Modul.\"\n Exit Sub\n End If\n Set cdPane = oVBE.ActiveCodePane\n Set mdl = cdPane.CodeModule\n For i = 1 To mdl.CountOfLines\n strZeile = Trim(mdl.Lines(i, 1))\n If Left(strZeile, 10) = \"Public Sub\" Or Left(strZeile, 11) = \"Private Sub\" _\n Or Left(strZeile, 3) = \"Sub\" Or Left(strZeile, 15) = \"Public Function\" _\n Or Left(strZeile, 16) = \"Private Function\" Or Left(strZeile, 8) _ = \"Function\" Or Left(strZeile, 15) = \"Public Property\" _ Or Left(strZeile, 16) = \"Private Property\" Then\n bolNummerieren = True\n bolJetztNicht = True\n Else\n bolJetztNicht = False\n End If\n If bolNaechsteNicht = True Then\n bolJetztNicht = True\n End If\n If Left(strZeile, 12) = \"End Function\" Or Left(strZeile, 7) = \"End Sub\" _\n Or Left(strZeile, 12) = \"End Property\" Then\n bolNummerieren = False\n bolJetztNicht = True\n End If\n bolNaechsteNicht = Right(strZeile, 1) = \"_\" \n Or Left(strZeile, 11) = \"Select Case\"\n If bolNummerieren = True And bolJetztNicht = False Then\n mdl.ReplaceLine i, i & \"0 \" & mdl.Lines(i, 1)\n End If\n Next i\nEnd Sub<\/pre>\nQuellcode 3<\/b><\/p>\n
Nun folgt der Kern der Routine: <\/p>\n
Eine For Next-Schleife durchläuft alle Zeilen des Moduls und stellt beim ersten Auftreten eines Prozedurkopfes die Variable bolNummerieren auf True ein. Findet die Routine das Ende einer Prozedur, setzt sie den Wert dieser Variablen wieder auf False.<\/p>\n
Private Sub evtEntnummerieren_Click(ByVal _ CommandBarControl As Object, handled As Boolean, _ CancelDefault As Boolean)\n Dim cdPane As VBIDE.CodePane\n Dim mdl As VBIDE.CodeModule\n Dim strZeile As String\n Dim i As Integer\n Dim j As Integer\n If oVBE.ActiveCodePane Is Nothing Then\n MsgBox \"No active code pane!\"\n Exit Sub\n End If\n Set cdPane = oVBE.ActiveCodePane\n Set mdl = cdPane.CodeModule\n Dim pos As Long\n For i = 1 To mdl.CountOfLines\n strZeile = mdl.Lines(i, 1)\n pos = 0\n j = 1\n Do While IsNumeric(Mid(strZeile, j, 1))\n pos = pos + 1\n j = j + 1\n Loop\n If pos > 0 Then\n mdl.ReplaceLine i, Mid(strZeile, pos + 2)\n End If\n Next i\nEnd Sub<\/pre>\nQuellcode 4<\/b><\/p>\n
Der Rest ist – mit zwei Ausnahmen – unkompliziert: Solange die Variable bolNummerieren auf True steht, setzt die Routine eine fortlaufende Nummer in Zehnerschritten vor die aktuelle Zeile. Ausnahmen sind Zeilen, die eine vorherige Zeile fortsetzen oder unmittelbar auf den Kopf einer Select Case-Konstruktion folgen.<\/p>\n
Nummerierung entfernen<\/h3>\n
Wenn die Nummerierung in Zehnerschritten nicht mehr ausreicht, weil nach einiger Zeit hier und da einige Zeilen hinzugekommen sind, sollte man die Nummerierung einfach anpassen können. Das erfolgt in zwei Schritten: Mit der in Quellcode 4 abgebildeten Routine entfernen Sie die Nummerierung aus dem gewünschten Modul und erneuern sie mit der soeben vorgestellten.<\/p>\n
Die Prozedur zum Entfernen von Zeilennummern ist recht einfach gestrickt. Sie entfernt einfach alle numerischen Zeichen zu Beginn einer jeden Zeile.<\/p>\n
Eigentlich trifft der Name Fehlerbehandlungs-Assistent nicht ganz den Punkt, denn er behandelt keine Fehler, sondern fügt einer Routine eine Fehlerbehandlung hinzu.<\/p>\n
Dabei macht die Prozedur umfangreichen Gebrauch von den Methoden und Eigenschaften des CodeModule-Objekts – was einiges an Arbeit erspart, wenn man nicht mit den üblichen Zeichenkettenfunktionen an die zu bearbeitende Routine herangehen möchte.<\/p>\n
Die Prozedur (s. Quellcode 5) überprüft nach dem Deklarationsteil zunächst, ob überhaupt ein Modul geöffnet ist, und falls ja, ob die Einfügemarke sich auf einer Sub-Prozedur, einer Function oder einer Property befindet. Dazu ermittelt sie die aktuelle Position der Einfügemarke (cdPane.GetSelection …) und verwendet die Eigenschaft ProcOfLine des aktuellen Moduls, um den Namen der zu ergänzenden Routine zu ermitteln.<\/p>\n
Als Nächstes bestimmt die Prozedur die Art der Routine. Dazu liest sie deren komplette erste Zeile ein, prüft auf Vorkommen von Sub, Function und Property und stellt die Eigenschaft lngProzedur auf den entsprechenden Wert ein.<\/p>\n
Private Sub evtFehlerbehandlung_Click(ByVal CommandBarControl As Object, _ handled As Boolean, CancelDefault As Boolean)\n Dim cdPane As VBIDE.CodePane\n Dim mdl As VBIDE.CodeModule\n ''Deklaration der String- und Long-Variablen aus Platzgründen ausgespart\n Dim lngProzedurart As Prozedurart\n If oVBE.ActiveCodePane Is Nothing Then\n MsgBox \"Bitte öffnen Sie zunächst das gewünschte Modul.\": Exit Sub\n End If\n Set cdPane = oVBE.ActiveCodePane\n Set mdl = cdPane.CodeModule\n cdPane.GetSelection lngStartLine, lngStartColumn, lngEndLine, lngEndColumn\n strProcName = mdl.ProcOfLine(lngStartLine, lngProcKind)\n If strProcName = \"\" Then\n MsgBox \"Bitte positionieren Sie die Einfügemarke auf der gewünschten Routine.\"\n Exit Sub\n End If\n lngProcStartLine = mdl.ProcBodyLine(strProcName, lngProcKind)\n If InStr(1, mdl.Lines(lngProcStartLine, 1), \"Function\") > 0 Then\n lngProzedurart = Funktion\n ''weitere Prüfungen auf ''Sub'' und ''Property'' aus Platzgründen ausgespart\n Else\n MsgBox \"Die Prozedurart ist nicht definiert.\"\n Exit Sub\n End If\n lngProcLines = mdl.ProcCountLines(strProcName, lngProcKind)\n lngStartLineFind = lngProcStartLine\n lngStartColumnFind = -1\n lngEndLineFind = lngProcStartLine + lngProcLines\n lngEndColumnFind = -1\n If mdl.Find(\"On Error\", lngStartLineFind, lngStartColumnFind, lngEndLineFind, _ lngEndColumnFind) Then\n MsgBox \"Es ist bereits eine Fehlerbehandlung vorhanden.\": Exit Sub\n End If\n If Right(Trim(mdl.Lines(lngProcStartLine, 1)), 1) = \"_\" Then\n lngStartLineFind = lngStartLineFind + 2\n Else\n lngStartLineFind = lngStartLineFind + 1\n End If\n Do\n If Right(Trim(mdl.Lines(lngStartLineFind, 1)), 1) = \"_\" Then\n lngStartLineFind = lngStartLineFind + 2\n ElseIf Left(Trim(mdl.Lines(lngStartLineFind, 1)), 1) = Chr(39) Then\n lngStartLineFind = lngStartLineFind + 1\n Else\n Exit Do\n End If\n Loop<\/pre>\nQuellcode 5 (erster Teil)<\/b><\/p>\n
Im folgenden Schritt durchsucht die Prozedur die betroffene Routine nach bereits vorhandenen Fehlerbehandlungen und bricht mit einer entsprechenden Meldung ab, wenn irgendwo in der Routine die On Error-Anweisung auftaucht.<\/p>\n
Ist das nicht der Fall, kann es losgehen: Die Prozedur ermittelt zunächst die Nummer der ersten Zeile nach der ersten Zeile der Routine. Das ist nicht mit einem Einzeiler getan, da die erste Zeile ja durchaus umbrochen sein kann. In die Zeile, die auf die so gefundene erste Zeile folgt, platziert die Prozedur dann den Beginn der Fehlerbehandlung (On Error Goto <Prozedurname>_Err).<\/p>\n
mdl.InsertLines lngStartLineFind, \" On Error Goto \" & strProcName & \"_Err\"\n strText = \" ''Fehlerbehandlung\" & vbCrLf\n strText = strText & strProcName & \"_Exit:\" & vbCrLf\n strText = strText & \" ''Restarbeiten\" & vbCrLf\n Select Case lngProzedurart\n Case Funktion\n strText = strText & \" Exit Function\" & vbCrLf\n Case SubProzedur\n strText = strText & \" Exit Sub\" & vbCrLf\n Case Property\n strText = strText & \" Exit Property\" & vbCrLf\n End Select\n strText = strText & strProcName & \"_Err:\" & vbCrLf\n strText = strText & \" Call GetError(\"\"\" & Mid(oVBE.ActiveWindow.Caption, 1, Len(oVBE.ActiveWindow.Caption) - 6) & \"\"\", \"\"\" & strProcName & \"\"\", Erl, \"\"Bemerkungen: .\/.\"\")\" & vbCrLf\n strText = strText & \" GoTo \" & strProcName & \"_Exit\"\n mdl.InsertLines lngEndLineFind - 1, strText\nEnd Sub<\/pre>\nQuellcode 5 (Fortsetzung)<\/b><\/p>\n
Bleibt nur noch, die eigentliche Fehlerbehandlung zusammenzusetzen und vor der letzten Zeile einzufügen. Die Fehlerbehandlung sieht dabei folgendermaßen aus, wobei die Texte in spitzen Klammern entsprechend der jeweiligen Prozedur ersetzt werden:<\/p>\n
''Fehlerbehandlung\n<Prozedurname>_Exit:\n''Restarbeiten\nExit <Prozedurart>\n<Prozedurname>_Err:\n Call GetError(\"<Modulname>\", _ \"<Prozedurname>\", Erl, _ \"Bemerkungen: .\/.\")\n GoTo <Prozedurname>_Exit<\/pre>\nBleibt dem Entwickler noch, die Restarbeiten an der entsprechenden Stelle einzufügen und gegebenenfalls den Aufruf der GetError-Funktion anzupassen.<\/p>\n
Hinweis<\/h3>\n
Weitere Informationen zur GetError-Funktion und deren Anwendung finden Sie im Beitrag Professionelle Fehlerbehandlung in dieser Ausgabe von Access im Unternehmen. <\/p>\n
Die vorgestellte Lösung kratzt nur an der Oberfläche dessen, was mit der beschriebenen Technik möglich ist. Eine weitere Anwendungsmöglichkeit wäre die Verwendung einer Funktion, die Property-Prozeduren auf Basis eines Variablennamens erstellt. Wenn man mit Klassenmodulen arbeitet und die Klasse einige nach außen zugängliche Variablen enthält, kann dies eine Menge Arbeit ersparen.<\/p>\n
Downloads zu diesem Beitrag<\/h2>\n
Enthaltene Beispieldateien:<\/p>\n
VBAExtensions.zip<\/p>\n