<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
VBA-Code ist die Quelle des Lebens in einer Access-Datenbankanwendung. Ohne VBA-Code gibt es keine professionelle Anwendung. Diese Meinung ist gängig. VBA-Code gibt man selbst ein; eventuell kopiert man die eine oder andere Routine und verwertet sie weiter. Auch diese Meinung kann man als landläufig bezeichnen. Es verhält sich aber ganz anders. Mit dem VBE-Objektmodell können Sie Code auch generieren, lesen oder anpassen lassen – mit ein wenig Fantasie sparen Sie sich so viel Arbeit. Mit dem vorliegenden Beitrag steigen Sie in die Programmierung der VBA-Entwicklungsumgebung ein und lernen die wichtigsten Grundlagen kennen.<\/b><\/p>\nHinweis<\/h3>\n
Die Beispieldatenbank zu diesem Beitrag heißt VBESamples00.mdb für Access 2000 und höher. Sie finden die Datenbank auf der Heft-CD oder im Internet unter http:\/\/www.access-im-unternehmen.de unter dem Shortlink 277. Beispiele für den Einsatz der hier vorgestellten Technik finden Sie im Beitrag Erweitern des VBA-Editors: CodeHistory, Shortlink 278 und Erweitern der VBA-Entwicklungsumgebung, Shortlink 237. <\/p>\n
Die Entwicklung von Anwendungen unter Verwendung von VBA-Code dürfte den meisten von Ihnen bekannt sein – zumindest, wenn Sie schon die eine oder andere Ausgabe dieses Magazins gelesen oder anderweitig Erfahrungen gesammelt haben. Die Eingabe des Codes ist dabei eine sehr individuelle Tätigkeit; jede Prozedur ist anders und außerdem hat jeder seinen eigenen Programmierstil. Aber ist das wirklich so überlegen Sie einmal, wie viele Male Sie Code aus anderen Anwendungen und Modulen herauskopiert haben, um ihn an anderer Stelle wiederzuverwenden – und die innerhalb von Prozeduren zu findenden Strukturen wiederholen sich auch immer wieder. Warum also nicht die Entwicklungsumgebung um ein paar Funktionen erweitern, die automatisch VBA-Code für Sie erstellen Vielleicht enthalten die folgenden Vorschläge einen Anreiz für Sie, sich mit dieser Technik auseinander zu setzen:<\/p>\n
Die oben genannten Lösungen lassen sich in einer Access-Datenbank unterbringen und von dort verwenden. Sie können auch von anderen Access-Anwendungen auf diese Datenbank verweisen und deren Funktionalität damit einbinden; es sind allerdings einige weitere Schritte mit dem Einsatz der Erweiterung verbunden.<\/p>\n
Die zweite, wesentlich effizientere Methode ist, die Funktionen für die Manipulation in einer .dll-Datei unterzubringen. Es gibt dort spezielle Elemente, die das direkte Einbinden in die VBA-Entwicklungsumgebung wesentlich erleichtern – weitere Informationen dazu finden Sie in den Beiträgen Erweitern der VBA-Entwicklungsumgebung in Ausgabe 5\/2004 und Erweitern des VBA-Editors: CodeHistory in der vorliegenden Ausgabe. Wer jedoch nicht über Microsoft Visual Studio verfügt, kann die hier verwendeten COM-Add-Ins nicht erstellen und muss auf das etwas weniger komfortable Access-Pendant zurückgreifen. Dazu finden Sie allerdings nachfolgend jede Menge Know-how und Beispiele.<\/p>\n
Für die folgenden Beispiele stellen Sie in der VBA-Entwicklungsumgebung zwei Verweise auf die folgenden Bibliotheken ein (s. Abb. 1):<\/p>\n
![](\"..\/fileadmin\/_temp_\/{FC9D6EE0-BE85-4514-83D6-D79F36AEDC64}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 1: Verweise für die Programmierung der VBE<\/b><\/p>\n
Bevor Sie sich an das Manipulieren des Codes begeben, lernen Sie die Objekte kennen, über die Sie auf den Code zugreifen können. Das Wurzelobjekt der VBE-Bibliothek ist das VBE-Objekt. Auf dieses müssen Sie zunächst einen Verweis erstellen – natürlich nicht, ohne vorher eine entsprechende Objektvariable zu deklarieren. Das Gerüst für die folgenden Beispielprozeduren sieht dementsprechend so aus:<\/p>\n
Public Function VBEInitialisieren()\n Dim objVBE As VBE\n Set objVBE = Application.VBE\n ''VBE-Aktionen\n Set objVBE = Nothing\nEnd Function<\/pre>\nDie Eingabe der Objektbezeichnung objVBE gefolgt von einem Punkt (.) lässt IntelliSense alle Elemente des Objektmodells anzeigen. Für einen detaillierten überblick schauen Sie sich das Ganze im Objektkatalog an (s. Abb. 2).<\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 2: Elemente des VBE-Objektmodells<\/b><\/p>\n
Fenster auflisten<\/h3>\n
Die Windows-Auflistung enthält alle in der VBA-Entwicklungsumgebung eingebauten Fenster, die sich über das Ansicht-Menü aktivieren lassen, und alle sonstigen Fenster wie die Code-Fenster der jeweiligen Module. Die folgende Prozedur listet die Titel aller Fenster auf:<\/p>\n
Public Function Fenster()\n Dim objWindow As Window\n For Each objWindow In VBE.Windows\n Debug.Print objWindow.Caption\n Next objWindow\nEnd Function<\/pre>\nDer Titel von Fenstern, die Code enthalten, besteht aus dem Modulnamen und dem angehängten Ausdruck (Code).<\/p>\n
Natürlich lassen sich über diese Auflistung noch weitere Fenstereigenschaften ermitteln; außerdem stehen zwei Methoden zur Verfügung, mit denen Sie ein Fenster schließen (Close) und den Fokus darauf setzen können (SetFocus).<\/p>\n
Codepanes<\/h3>\n
Die Fenster, die den Code eines Klassen- oder Standardmoduls enthalten, heißen Codepane. Die Titel aller Codepanes können Sie mit folgender Prozedur ausgeben:<\/p>\n
Public Function CodepanesZeigen()\n Dim objCodepane As CodePane\n For Each objCodepane In VBE.CodePanes\n Debug.Print _ objCodepane.Window.Caption\n Next objCodepane\nEnd Function<\/pre>\nDabei greifen Sie über die Windows-Eigenschaft auf das zugrunde liegende Fenster-Element zu und geben dessen Titel aus. Der Zugriff auf ein CodePane über die CodePanes-Auslistung ist nur sinnvoll, wenn Sie den Index des benötigten CodePane kennen oder wenn Sie eine Aktion mit allen CodePanes durchführen möchten.<\/p>\n
Oft möchte man direkt auf das aktuell aktive CodePane zugreifen. Dazu kann man folgenden Verweis verwenden:<\/p>\n
VBE.ActiveCodePane<\/pre>\nUm damit den Titel des CodePane zu ermitteln, verwenden Sie folgende Erweiterung:<\/p>\n
VBE.ActiveCodePane.Window.Caption<\/pre>\nDas CodePane-Objekt enthält noch weitere interessante Methoden und Eigenschaften, die später in einem anderen Zusammenhang vorgestellt werden.<\/p>\n
CodeModules<\/h3>\n
Das für die nachfolgenden Beispiele wichtigste Element ist das CodeModule. Das CodeModule enthält den eigentlichen Code des durch das CodePane repräsentierten Moduls. Auf den Inhalt eines CodeModule-Objekts können Sie auf unterschiedliche Weise zugreifen. Am einfachsten ist der Zugriff auf das CodeModule des aktuellen CodePanes:<\/p>\n
Public Function CodeModulesAnzeigen()\n Dim objCodeModule As CodeModule\n Set objCodeModule = _ VBE.ActiveCodePane.CodeModule\n With objCodeModule\n .CountOfLines\n End With\n Set objCodeModule = Nothing\nEnd Function<\/pre>\nWenn Sie auf das CodeModule eines bestimmten Moduls zugreifen möchten und dieses namentlich kennen, verwenden Sie die folgende Anweisung (ohne Zeilenumbruch):<\/p>\n
VBE.ActiveVBProject.VBComponents(\"mdlVBE\").CodeModule.CountOfLines<\/pre>\nDamit haben Sie noch ein weiteres Element des VBE-Objektmodells kennen gelernt: ActiveVBProject gibt einen Verweis auf das aktuell in der VBA-Entwicklungsumgebung verwendete Projekt an.<\/p>\n
Einbinden weiterer VBA-Projekte<\/h3>\n
Möglicherweise fragen Sie sich, wie man mehr als ein VBA-Projekt gleichzeitig in der VBA-Entwicklungsumgebung verwenden kann. Das geht ganz einfach: öffnen Sie einfach den Verweise-Dialog über den Menüpunkt Extras\/Verweise und klicken Sie dort auf die Schaltfläche Durchsuchen. Stellen Sie im nun erscheinenden Dialog den Dateityp Microsoft Office Access-Datenbanken (*.mdb) ein und wählen Sie eine andere Datenbank als die aktuelle aus.<\/p>\n
Public Function CreateModule(strModulename As String, lngModuletype As Modultype)\n Dim objVBComponent As VBComponent\n Set objVBComponent = VBE.ActiveVBProject.VBComponents.Add(lngModuletype)\n objVBComponent.Name = strModulename\n DoCmd.Save acModule, strModulename\n Set objVBComponent = Nothing\nEnd Function<\/pre>\nQuellcode 1<\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 3: Bearbeiten eines VBA-Projekts einer anderen Datenbank<\/b><\/p>\n
Der Projekt-Explorer zeigt das aktuelle und zusätzlich das per Verweis verfügbar gemachte VBA-Projekt an. Sie können auf die Module dieses Projekts zugreifen und sogar neue Module anlegen und bearbeiten (s. Abb. 3).<\/p>\n
Wenn Sie mehrere VBA-Projekte gleichzeitig in der VBA-Entwicklungsumgebung anzeigen, empfiehlt sich der explizite Zugriff auf eines der Projekte statt der Verwendung der Funktion ActiveVBProject:<\/p>\n
VBE.VBProjects(\"VBESample\").VBComponents(\"mdlVBE\").CodeModule<\/pre>\nDie Arbeit mit dem in den Modulen enthaltenen VBA-Code schließt auch das Anlegen, Löschen und Bearbeiten der Module ein.<\/p>\n
Erstellen eines Moduls<\/h2>\n
Das Erstellen eines Moduls läuft in mehreren Schritten ab. über die Add-Methode der Auflistung VBComponents legen Sie ein neues Modul an. Um seinen Namen einzustellen, verweisen Sie direkt per entsprechender Objektvariable auf das neue Objekt. Schließlich müssen Sie das Modul noch speichern; dazu verwenden Sie die herkömmliche DoCmd.Save-Methode. Die folgende Prozedur legt ein neues Modul mit dem gewünschten Namen und Typ an. Es gibt drei Typen: Standardmodule, Klassenmodule und Formular- oder Berichtsmodule. Für das Festlegen des Typs verwendet die Prozedur eine Enum-Auflistung. Diese dient lediglich der besseren Lesbarkeit der Konstanten, die Werte selbst stimmen mit den Originalkonstanten überein:<\/p>\n
Public Enum Modultype\n Classmodule = 2\n FormReportModul = 100\n Standardmodule = 1\nEnd Enum<\/pre>\nDie Prozedur sieht schließlich wie in Quellcode 1 aus. Mit dem Aufruf aus Abb. 4 legen Sie beispielsweise ein Klassenmodul namens clsTest an.<\/p>\n
Public Function DeleteModule(strModulename As String)\n Dim objVBComponent As VBComponent\n Set objVBComponent = VBE.ActiveVBProject.VBComponents(strModulename)\n VBE.ActiveVBProject.VBComponents.Remove objVBComponent\n Set objVBComponent = Nothing\nEnd Function<\/pre>\nQuellcode 2<\/b><\/p>\n
Public Function ListModules()\n Dim objVBComponent As VBComponent\n For Each objVBComponent In VBE.ActiveVBProject.VBComponents\n Debug.Print objVBComponent.Name\n Next objVBComponent\nEnd Function<\/pre>\nQuellcode 3<\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 4: Anlegen eines neuen Klassenmoduls<\/b><\/p>\n
Hinweis<\/h3>\n
Diese und die folgenden Beispielprozeduren enthalten aus Platzgründen keine Fehlerbehandlung. Im vorliegenden Fall müssten Sie beispielsweise noch Vorkehrungen für den Fall treffen, dass das anzulegende Klassenmodul bereits vorhanden ist. <\/p>\n
Löschen eines Moduls<\/h2>\n
Für das Löschen eines Moduls erstellen Sie zunächst eine Objektvariable, die auf das Modul verweist. Anschließend verwenden Sie die Remove-Methode der VBComponents-Auflistung.<\/p>\n
Die Funktion aus Quellcode 2 kapselt diese Funktionalität und erwartet lediglich den Namen des Moduls als Parameter.<\/p>\n
Auflisten der bestehenden Module<\/h2>\n
Auf einzelne Module können Sie über die VBComponents-Auflistung zugreifen, wie Sie in den beiden vorhergehenden Beispielen sehen konnten.<\/p>\n
Das Auflisten aller Module des aktuellen Projekts erfolgt ebenfalls über diese Auflistung, wie Quellcode 3 zeigt.<\/p>\n
Nachdem Sie erfahren haben, wie Sie auf verschiedene Art und Weise auf die Code-Module zugreifen können, schauen Sie sich nun die Funktionen an, um auf die Eigenschaften der Module und des enthaltenen Codes zuzugreifen.<\/p>\n
Die Eigenschaften und Methoden sind auf zwei Objekte aufgeteilt: auf das CodePane-Objekt und das darin enthaltene CodeModule-Objekt.<\/p>\n
Eigenschaften und Methoden des CodePane-Objekts<\/h2>\n
Die im CodePane-Objekt enthaltenen Elemente beziehen sich eher auf die sichtbaren Eigenschaften des im Code-Fenster angezeigten Codes.<\/p>\n
Oberste Zeile<\/h3>\n
Die Eigenschaft TopLine gibt die Nummer der Zeile zurück, die ganz oben im Fenster angezeigt wird. Nach dem öffnen eines Code-Fensters ist dies typischerweise die 1:<\/p>\n
VBE.ActiveCodePane.TopLine\n 1 <\/pre>\nScrollen Sie ein wenig herunter und lassen Sie sich den Eigenschaftswert erneut ausgeben, um die Veränderung zu beobachten.<\/p>\n
Public Function Markierungskoordinaten()\n Dim objCodePane As CodePane\n Dim lngStartLine As Long\n Dim lngStartColumn As Long\n Dim lngEndLine As Long\n Dim lngEndColumn As Long\n Set objCodePane = VBE.ActiveCodePane\n With objCodePane\n .GetSelection lngStartLine, lngStartColumn, lngEndLine, lngEndColumn\n MsgBox \"Die Koordinaten lauten:\" & vbCrLf _\n & \"Erste Zeile: \" & lngStartLine & vbCrLf _\n & \"Erste Spalte: \" & lngStartColumn & vbCrLf _\n & \"Letzte Zeile: \" & lngEndLine & vbCrLf _\n & \"Letzte Spalte: \" & lngEndColumn & vbCrLf\n End With\n Set objCodePane = Nothing\nEnd Function<\/pre>\nQuellcode 3<\/b><\/p>\n
Public Function MarkierungSetzen()\n Dim objCodePane As CodePane\n Dim lngStartLine As Long\n Dim lngStartColumn As Long\n Dim lngEndLine As Long\n Dim lngEndColumn As Long\n Set objCodePane = VBE.ActiveCodePane\n lngStartLine = 1\n lngStartColumn = 1\n lngEndLine = 2\n lngEndColumn = 2\n With objCodePane\n .SetSelection lngStartLine, lngStartColumn, lngEndLine, lngEndColumn\n End With\n Set objCodePane = Nothing\nEnd Function<\/pre>\nQuellcode 4<\/b><\/p>\n
Koordinaten der aktuellen Markierung<\/h3>\n
Für viele Funktionen ist die Kenntnis der aktuellen Markierung interessant. Die VBA-Entwicklungsumgebung erlaubt keinen Blockauswahl-Modus wie etwa Textpad. Die vier von der Funktion GetSelection gefüllten Parameter geben daher an, in welcher Zeile und Spalte das erste Zeichen und wo das letzte Zeichen der Markierung liegt. Das bedeutet, dass der Wert für die erste Spalte durchaus größer als der Wert für die letzte Spalte sein kann.<\/p>\n
Allgemein ist zu dieser Funktion Folgendes zu bemerken: Die vier Parameter sind keine Eingangs-, sondern Ausgangsparameter, die erst bei Ausführung der Funktion gefüllt werden. Das bringt mit sich, dass Sie statt konkreter Werte Variablen für diese Parameter angeben müssen, die Sie vorher deklarieren.<\/p>\n
Im Detail sieht das wie in der Prozedur aus Quellcode 3 aus.<\/p>\n
Markierung setzen<\/h3>\n
Das Pendant für die Funktion GetSelection heißt SetSelection. Damit können Sie einen vorgegebenen Bereich im aktuellen CodePane markieren. Die Routine aus Quellcode 4 zeigt, wie es funktioniert.<\/p>\n
Wenn Sie diese Prozedur vom Direktfenster aus aufrufen, werden Sie die Wirkung möglicherweise nicht erkennen können. Das liegt daran, dass der Fokus weiterhin auf dem Direktfenster liegt.<\/p>\n
Sie können dies umgehen, indem Sie die Prozedur von einem Formular aus aufrufen. Legen Sie dazu eine einfache Schaltfläche an und fügen Sie der Ereignisprozedur, die beim Klicken ausgelöst wird, den Prozeduraufruf Markierung setzen hinzu.<\/p>\n
Wenn Sie die Prozedur auf diesem Wege aufgerufen haben und dann zur VBA-Entwicklungsumgebung wechseln, ist der gewünschte Code markiert.<\/p>\n
Mit den Methoden und Eigenschaften des CodeModule-Objekts stellt das VBE-Objektmodell Werkzeuge zum Lesen, Bearbeiten und Erstellen von Code bereit.<\/p>\n
Nachfolgend erfahren Sie zunächst, wie Sie lesend auf den Code zugreifen; anschließend geht es um das Bearbeiten, Hinzufügen und Löschen von Code.<\/p>\n
Hinweis<\/h3>\n
Wenn nachfolgend von Prozedur die Rede ist, sind verallgemeinert Sub-, Function und Property Let\/Set\/Get-Prozeduren gemeint. <\/p>\n
Lesender Zugriff auf Quellcode<\/h2>\n
Das VBE-Objektmodell stellt die folgenden Eigenschaften und Methoden für den lesenden Zugriff zur Verfügung:<\/p>\n
CountOfDeclarationLines: Gibt die Anzahl der Zeilen des Deklarationsbereichs der Prozedur zurück. Das sind alle Zeilen von der ersten Zeile des Moduls bis zur letzten Zeile vor der ersten Prozedur. Dabei gehören alle Leerzeilen, die sich unmittelbar vor der Prozedur befinden, zu dieser Prozedur.<\/li>\n CountOfLines: Gibt die Gesamtanzahl der Zeilen des Moduls inklusive Deklarationsbereich zurück.<\/li>\n Find: Dient der Suche nach einem bestimmten Ausdruck. Liefert die Koordinaten der Fundstelle zurück.<\/li>\n Lines: Gibt eine bestimmte Anzahl Zeilen von einer festgelegten Startzeile an zurück.<\/li>\n ProcBodyLine: Gibt die Zeilennummer der Deklarationszeile einer Prozedur zurück.<\/li>\n ProcCountLines: Gibt die Anzahl der Zeilen einer Prozedur zurück.<\/li>\n ProcOfLine: Gibt den Namen der Prozedur in einer angegebenen Zeile zurück und einen Leerstring, wenn die angegebene Zeile im Deklarationsbereich liegt.<\/li>\n ProcStartLine: Gibt die erste Zeile der angegebenen Prozedur zurück. Wenn sich unmittelbar vor der ersten Zeile Leerzeilen befinden, wird die Zeilennummer der ersten dieser Zeilen zurückgegeben.<\/li>\n Analysieren eines Moduls<\/h3>\n
Leider bietet das CodeModule-Objekt keine Möglichkeit, per Auflistung auf die einzelnen Prozeduren zuzugreifen. Das ist allerdings eine passende Gelegenheit, die soeben beschriebenen Eigenschaften und Methoden an einem handfesten Beispiel zu demonstrieren.<\/p>\n
Die Prozedur aus Quellcode 5 zeigt die Anwendung aller Elemente außer der Find-Methode.<\/p>\n
Die Prozedur verwendet eine Objektvariable namens objCodeModule für den Zugriff auf das aktuelle CodeModule-Objekt. Ein Modul kann mehrere Prozeduren, aber nur einen Deklarationsbereich enthalten, und dieser liegt immer am Anfang des Moduls. Die Prozedur ermittelt zunächst die Anzahl der Zeilen dieses Bereichs mit der CountOfDeclarationLines-Eigenschaft und gibt sie im Direktfenster aus.<\/p>\n
Anschließend durchläuft die Prozedur alle übrigen Zeilen des Moduls beginnend mit der ersten Zeile nach dem Deklarationsbereich, sofern noch weitere Zeilen vorhanden sind. Das überprüft die Do…While-Schleife, bevor sie mit der Analyse der ersten Prozedur beginnt, indem sie die Nummer der aktuellen Zeile mit derjenigen der letzten Zeile vergleicht. Für das Ermitteln der Nummer der letzten Zeile ist dabei die CountOfLines-Eigenschaft verantwortlich.<\/p>\n
Die erste Zeile nach dem Deklarationsbereich enthält – sofern überhaupt eine Prozedur vorhanden ist – deren erste Zeile. Mit der ProcOfLine-Eigenschaft, die als Parameter die zu untersuchende Zeile und eine Variable zur Rückgabe des Prozedurtyps erwartet, ermittelt man den Namen der Prozedur, zu der diese Zeile gehört.<\/p>\n
Die Prozedur Modulanalyse soll hilfreiche Informationen über das Modul ausgeben, daher gibt sie sich nicht mit der Ausgabe des Prozedurtyps in Form des entsprechenden konstanten Zahlenwerts zufrieden, sondern präsentiert einen entsprechenden Ausdruck wie Sub-Prozedur, Function-Prozedur, Property Get-Prozedur, Property Let-Prozedur oder Property Set-Prozedur.<\/p>\n
Die von der Funktion ProcOfLine gefüllte Variable enthält Werte von 0 bis 3, wobei die Zahlen den Konstanten aus Tab. 1 entsprechen.<\/p>\n
Wie Sie der Tabelle entnehmen können, teilen sich Sub- und Function-Prozeduren eine Konstante. Um detailliertere Informationen zum Typ auszugeben, müssen Sie die Prozedur also genauer untersuchen. Nun ist bekannt, dass die Deklarationszeile von Sub- oder Function-Prozeduren irgendwo in der Deklarationszeile entweder das Schlüsselwort Sub oder Function enthält. Dummerweise können diese Schlüsselwörter aber auch beispielsweise im Prozedurnamen vorkommen und die Position der Schlüsselwörter ist auch nicht konstant: Manchmal beginnt die Deklaration der Prozedur mit einem der Schlüsselwörter, mal beginnt sie mit Public oder Private.<\/p>\n
\n
\n \n Zahlenwert<\/b><\/p>\n<\/td>\n
\n Konstante (Bedeutung)<\/b><\/p>\n<\/td>\n<\/tr>\n
\n \n 0<\/p>\n<\/td>\n
\n vbext_pk_Proc (Sub- oder Function-Prozedur)<\/p>\n<\/td>\n<\/tr>\n
\n \n 1<\/p>\n<\/td>\n
\n vbext_pk_Let (Property Let-Prozedur)<\/p>\n<\/td>\n<\/tr>\n
\n \n 2<\/p>\n<\/td>\n
\n vbext_pk_Set (Property Set-Prozedur)<\/p>\n<\/td>\n<\/tr>\n
\n \n 3<\/p>\n<\/td>\n
\n vbext_pk_Get (Property Get-Prozedur)<\/p>\n<\/td>\n<\/tr>\n<\/table>\n
Tab. 1: Konstanten des Parameters ProcKind<\/b><\/p>\n
Die Prozedur Modulanalyse umschifft dieses Problem, indem sie einfach die letzte Zeile der Prozedur untersucht – und die heißt immer End Sub oder End Function. Dazu lässt sich auch gut die Funktionsweise der Eigenschaften ProcStartLine und ProcCountLines demonstrieren, denn die um eins geminderte Summe dieser beiden Werte entspricht der Nummer der letzten Zeile der Prozedur. Und die enthält die gesuchten Schlüsselwörter, mit denen sich die genaue Art der Prozedur ermitteln lässt.<\/p>\n
Der Rest ist Fleißarbeit: Die Eigenschaften ProcCountLines, ProcStartLine und ProcBodyLine geben die jeweiligen Werte aus. Dabei ist eines zu beachten: Alle drei enthalten ebenfalls den weiter oben beschriebenen Parameter ProcKind. Während die Funktion ProcOfLine diesen Wert füllt, müssen Sie ihn bei den übrigen Eigenschaften angeben.<\/p>\n
Solange Sie dafür eine Variable deklarieren und die Funktion ProcOfLine vor den anderen Funktionen aufrufen, treten keine Probleme auf – sofern Sie die gleiche, nun gefüllte Variable auch als Parameter dieser Funktionen angeben.<\/p>\n
Public Sub Modulanalyse()\n Dim objCodeModule As CodeModule\n Dim lngLine As Long\n Dim lngProcKind As Long\n Dim strProcName As String\n Dim strProcKind As String\n Dim lngProcStartLine As Long\n Dim strLine As String\n Dim lngProcCountLines As Long\n Set objCodeModule = VBE.ActiveCodePane.CodeModule\n With objCodeModule\n lngLine = .CountOfDeclarationLines\n Debug.Print \"Deklarationsbereich: \" & lngLine & \" Zeile(n)\"\n lngLine = lngLine + 1\n Do While lngLine <= .CountOfLines\n strProcName = .ProcOfLine(lngLine, lngProcKind)\n Select Case lngProcKind\n Case vbext_pk_Proc\n lngProcStartLine = .ProcStartLine(strProcName, lngProcKind)\n lngProcCountLines = .ProcCountLines(strProcName, lngProcKind)\n strLine = .Lines(lngProcStartLine + lngProcCountLines - 1, 1)\n If strLine = \"End Sub\" Then\n strProcKind = \"Sub-Prozedur\"\n Else\n strProcKind = \"Function-Prozedur\"\n End If\n Case vbext_pk_Let\n strProcKind = \"Property Let-Prozedur\"\n Case vbext_pk_Set\n strProcKind = \"Property Set-Prozedur\"\n Case vbext_pk_Get\n strProcKind = \"Property Get-Prozedur\"\n End Select\n Debug.Print vbCrLf\n Debug.Print \"Prozedurname: \" & strProcName\n Debug.Print \"=============================\"\n Debug.Print \"Anzahl Zeilen: \" & .ProcCountLines(strProcName, _ lngProcKind)\n Debug.Print \"Startzeile: \" & .ProcStartLine(strProcName, _ lngProcKind)\n Debug.Print \"Deklarationszeile: \" & .ProcBodyLine(strProcName, _ lngProcKind)\n Debug.Print \"Prozedurtyp: \" & strProcKind\n lngLine = lngLine + .ProcCountLines(strProcName, lngProcKind)\n Loop\n End With\n Set objCodeModule = Nothing\nEnd Sub<\/pre>\nQuellcode 5<\/b><\/p>\n
Nach der Ausgabe der Informationen einer Prozedur erhöht eine entsprechende Anweisung den Zähler lngLine so, dass er auf der ersten Zeile der folgenden Prozedur steht und die Do…While-Schleife den nächsten Kandidaten untersucht oder die letzte Zeile erreicht ist und die Prozedur beendet wird.<\/p>\n
Suchen mit der Find-Methode<\/h3>\n
Die Find-Methode arbeitet wie die Methoden GetSelection und SetSelection mit vier Parametern, die zur Rückgabe der Koordinaten des gesuchten Ausdrucks dienen. Zusätzlich enthält sie einen weiteren Parameter, der zur Angabe des gesuchten Ausdrucks dient.<\/p>\n
Die Methode hat weitere drei Parameter:<\/p>\n
WholeWord: Sucht nur nach kompletten Wörtern.<\/li>\n MatchCase: Beachtet Groß- und Kleinschreibung.<\/li>\n PatternSearch: Lässt Verwendung von Platzhaltern wie Sternchen (*) und Fragezeichen () zu.<\/li>\n Ein Beispiel für den Einsatz dieser Methode finden Sie weiter unten in Quellcode 6.<\/p>\n
Bearbeiten des Quellcodes<\/h2>\n
Zum Bearbeiten des Quellcodes stehen die folgenden Methoden zur Verfügung:<\/p>\n
AddFromFile: Fügt den Inhalt der angegebenen Textdatei am Anfang des Moduls ein.<\/li>\n AddFromString: Fügt den im Parameter angegebenen Text am Anfang des Moduls ein.<\/li>\n CreateEventProc: Erzeugt eine Ereignisprozedur. Erwartet den Namen des Ereignisses (zum Beispiel OnClick) und den Namen des Objekts (zum Beispiel cmdButton) als Parameter und funktioniert nur, wenn das Objekt existiert und dieses das Ereignis unterstützt.<\/li>\n InsertLines: Fügt den angegebenen Text inklusive Zeilenumbruch in die gewünschte Zeile ein.<\/li>\n DeleteLines: Löscht die angegebene Zeilenanzahl von der gewünschten Zeile an.<\/li>\n ReplaceLine: Ersetzt den Inhalt einer Zeile durch den angegebenen Inhalt.<\/li>\n Einfaches Hinzufügen von Code<\/h3>\n
Die beiden Methoden AddFromFile und AddFromText sind die einfachste Möglichkeit, Code zu einer bestehenden Prozedur hinzuzufügen.<\/p>\n
Da sie den Code jedoch direkt am Anfang des Moduls einfügen, sind sie praktisch nur direkt nach dem Anlegen eines Moduls und zum Hinzufügen kompletter Modulinhalte zu verwenden – beispielsweise, um den Inhalt eines kompletten Moduls zu kopieren.<\/p>\n
Anlegen einer Ereignisprozedur<\/h3>\n
Die Methode CreateEventProc ist besonders dann interessant, wenn Steuerelemente und deren Elemente automatisch und in großen Mengen angelegt werden sollen.<\/p>\n
Die Methode erwartet den englischen Namen des Ereignisses und den Namen des Objekts – dabei kann es sich um ein Formular, einen Bericht oder ein darin enthaltenes Steuerelement sowie um sonstige Objekte handeln.<\/p>\n
Fehler treten dann auf, wenn es entweder das Objekt nicht gibt oder dieses das angegebene Ereignis nicht unterstützt beziehungsweise dieses gar nicht existiert.<\/p>\n
Ein Beispielaufruf für die Beim Klicken-Prozedur einer Schaltfläche namens cmdKlick sieht folgendermaßen aus (in einer Zeile):<\/p>\n
VBE.ActiveCodePane.CodeModule.CreateEventProc \"Click\", \"cmdKlick\"<\/pre>\nDer Aufruf erzeugt folgenden Prozedurrumpf:<\/p>\n
Private Sub cmdKlick_Click()\nEnd Sub\nPublic Function FillEvent(strEvent As String, strObject As String, strText As String)\n Dim objCodeModule As CodeModule\n Dim lngStartLine As Long\n Dim lngStartColumn As Long\n Dim lngEndLine As Long\n Dim lngEndColumn As Long\n Dim bolResult As Boolean\n Set objCodeModule = VBE.ActiveCodePane.CodeModule\n bolResult = objCodeModule.Find(strObject & \"_\" _ & strEvent, lngStartLine, lngStartColumn, _ lngEndLine, lngEndColumn)\n If bolResult = True Then\n objCodeModule.InsertLines lngStartLine + 1, _ strText\n Else\n MsgBox \"Die angegebene Prozedur konnte \" _\n & \"nicht gefunden werden.\"\n End If\n Set objCodeModule = Nothing\nEnd Function<\/pre>\nQuellcode 6<\/b><\/p>\n
Zeilen einfügen<\/h3>\n
Etwas flexibler als die Methoden AddFromFile und AddFromText ist die Methode InsertLines. Die Methode erwartet die Eingabe der Zeile, in die der Text eingefügt werden soll, und den einzufügenden Text.<\/p>\n
Wenn Sie der soeben erstellten Prozedur eine Zeile hinzufügen möchten, verwenden Sie eine Prozedur wie aus Quellcode 4. Die Prozedur erwartet die englische Bezeichnung des Ereignisses, den Namen des Objekts sowie den für die Prozedur einzufügenden Text. Sie sucht mit der Find-Methode nach der Zeile, in der sich der Prozedurkopf befindet, und speichert deren Nummer in der Variablen lngStartline (die anderen Koordinaten werden natürlich auch gespeichert, aber nicht benötigt).<\/p>\n
Wenn die Find-Methode erfolgreich war und den Wert True zurückgibt, fügt die Prozedur die angegebene Zeile mit der InsertLines-Methode in die erste Zeile nach der Prozedurdeklaration ein; falls nicht, erscheint eine entsprechende Meldung. Der folgende Aufruf der Prozedur fügt beispielsweise eine MsgBox-Anweisung zur Ereignisprozedur cmdKlick_Click hinzu:<\/p>\n
FillEvent \"Click\", \"cmdKlick\", \" MsgBox \"\"Hallo!\"\"\"<\/pre>\nZeilen ersetzen<\/h3>\n
Die Prozedur aus Quellcode 6 hat noch einen Haken: Die leere Zeile im Prozedurrumpf wird nicht überschrieben, sondern einfach nach unten verschoben. Das schreit nach dem Einsatz der ReplaceLines-Methode. Nach einer überprüfung, ob die erste Zeile hinter der Prozedurdeklaration leer ist, kann man diese durch die neue Zeile ersetzen. Löschen Sie einfach die Zeile<\/p>\n
objCodeModule.InsertLines lngStartLine + 1, strText<\/pre>\nund ersetzen Sie diese durch das folgende If…Then-Konstrukt:<\/p>\n
If Trim(objCodeModule.Lines( _ lngStartLine + 1, 1)) = \"\" Then\n objCodeModule.ReplaceLine _ lngStartLine + 1, strText\nElse\n objCodeModule.InsertLines _ lngStartLine + 1, strText\nEnd If<\/pre>\nZeilen löschen<\/h3>\n
Das Löschen von Zeilen erfolgt mit der Methode DeleteLines. Die Methode erwartet lediglich die Nummer der ersten zu löschenden Zeile und deren Gesamtanzahl.<\/p>\n
Downloads zu diesem Beitrag<\/h2>\n
Enthaltene Beispieldateien:<\/p>\n
VBESamples00.mdb<\/p>\n