<\/p>\n
Der VBA-Editor ist die Gemeinsamkeit der Office-Anwendungen wie Access, Excel, Outlook, PowerPoint und Word. Wer eine oder mehrere dieser Anwendungen programmiert, um dem Benutzer die Arbeit damit zu erleichtern, kennt sich mehr oder weniger mit VBA aus. In der Regel wird im Arbeitsalltag eines Entwicklers jede Codezeile von Hand neu programmiert. Gegebenenfalls kopiert man bestehenden Code und passt diesen an den jeweiligen Anwendungszweck an. Aber warum nicht einen Schritt weitergehen und VBA-Code zur Erstellung von VBA-Code selbst nutzen? Visual Basic bietet eigens zum Zweck der Programmierung der Elemente und des Codes im VBA-Editor eine eigene Bibliothek namens Microsoft Visual Basic for Applications Extensibility 5.3. Welche Möglichkeiten diese allgemein bietet und welche Elemente, Eigenschaften und Methoden sie bereitstellt, schauen wir uns in diesem Artikel an.<\/b><\/p>\n
Der VBA-Editor ist die Entwicklungsumgebung für die Programmierung der verschiedenen Office-Anwendungen und der darin enthaltenen Dokumente und Elemente. Er zeigt im Projekt-Explorer die programmierbaren Elemente wie Standardmodule und Klassenmodule an und erlaubt es, den Code dieser Elemente im Code-Editor anzuzeigen und zu bearbeiten.<\/p>\n
Die Codeeingabe selbst ist bis auf wenige Hilfestellungen durch IntelliSense Aufgabe des Entwicklers – hier ist viel Tipparbeit angezeigt oder gegebenenfalls noch das Kopieren und Anpassen bereits vorhandenen Codes.<\/p>\n
IntelliSense unterstützt uns allerdings auch nur dabei, den Datentyp für Variablen auszuwählen oder die Eigenschaften oder Methoden von Objektvariablen zu selektieren. Wenn wir mehr aus der Entwicklungsumgebung herausholen wollen, müssen wir uns also selbst helfen.<\/p>\n
Dabei können wir bereits mit den üblichen Mitteln von VBA Einiges erreichen: So können wir die Zeichenkettenfunktionen in Kombination mit Schleifen nutzen, um bestimmte Abfolgen von Anweisungen im Direktbereich des VBA-Editors auszugeben, die wir dann kopieren und in unseren Code einfügen.<\/p>\n
Wir können jedoch noch viel mehr erreichen, wenn wir eine Bibliothek namens Microsoft Visual Basic for Applications Extensibility 5.3 <\/b>einbinden. Diese fügen wir über den Verweise<\/b>-Dialog, den wir mit dem Menübefehl Extras|Verweise <\/b>öffnen, zum aktuellen VBA-Projekt hinzu. Dazu versehen wir den Eintrag wie in Bild 1 mit einem Haken.<\/p>\n
![\"Setzen](\"..\/fileadmin\/_temp_\/2024_02\/pic_426_001.png\")
<\/p>\n
Bild 1: Setzen eines Verweises auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3<\/span><\/b><\/p>\n Anschließend können wir uns im Objektkatalog, zu öffnen mit der Taste F2<\/b>, die Klassen und Enumerationen dieser Bibliothek ansehen (siehe Bild 2).<\/p>\n Bild 2: Die Elemente der Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3<\/span><\/b><\/p>\n Damit nur die Elemente der hier VBIDE <\/b>genannten Bibliothek angezeigt werden, haben wir diesen Eintrag im Kombinationsfeld ganz oben ausgewählt.<\/p>\n Danach sehen wir in der linken Liste alle Klassen und Enumerationen dieser Bibliothek und rechts die Elemente des aktuell markierten Eintrags der linken Liste, hier der Hauptklasse VBE<\/b>.<\/p>\n Und hier ist eine kurze Beschreibung der Elemente, die wir direkt über die Hauptklasse erreichen können:<\/p>\n Beim Deklarieren der Elemente der VB-Editor-Bibliothek können wir die übergeordnete Klasse VBIDE <\/b>verwenden. Damit erhalten wir dann alle Elemente dieser Bibliothek per IntelliSense:<\/p>\n Bei Referenzieren nutzen wir hingegen einfach VBE<\/b>, zum Beispiel:<\/p>\n Die Fenster im VBA-Editor können wir mit der Windows<\/b>-Auflistung durchlaufen. Dabei verwenden wir als Laufvariable der For Each<\/b>-Schleife eine Variable des Typs Window<\/b>:<\/p>\n Hier geben wir den Typ, den Fensterstatus und die Beschriftung aus, was bei einem geöffneten Modul wie in Bild 3 aussieht.<\/p>\n Bild 3: Ausgabe der Fenster mit einigen Eigenschaftswerten<\/span><\/b><\/p>\n Was die einzelnen Zahlen für die Eigenschaft Type <\/b>bedeuten, können wir der Enumeration vbext_WindowType <\/b>entnehmen, die wir im Objektkatalog finden. 0 <\/b>steht beispielsweise für vbext_wt_CodeWindow<\/b>. Die anderen Werte stehen für die jeweiligen Fenstertypen wie Direktbereich, Projekt-Explorer und so weiter.<\/p>\n Wenn wir einmal die Fenster und ihre Position steuern wollen, können wir diese und andere Eigenschaften der Window<\/b>-Objekte nutzen. Diese liefern beispielsweise auch die Position und Größe der Fenster.<\/p>\n Der VBA-Editor kann durchaus einmal mehrere VBA-Projekte gleichzeitig im Projekt-Explorer anzeigen, beispielsweise wenn aktuell ein Add-In geladen ist.<\/p>\n Diese können wir über die Auflistung VBProjects <\/b>durchlaufen:<\/p>\n Das Element VBProject <\/b>liefert neben dem Namen noch einige weitere interessante Eigenschaften:<\/p>\n Wenn mehrere VBA-Projekte geladen sind, liefert ActiveVBProject <\/b>abhängig von dem Ort, wo es ausgeführt wird, unterschiedliche Ergebnisse. Wenn wir es im Direktbereich aufrufen, erhalten wir einen Verweis auf das VBA-Projekt, das gerade im Projekt-Explorer den Fokus hat. Wenn wir es aus einem Modul heraus aufrufen, erhalten wir mit ActiveVBProject<\/b> einen Verweis auf das VBA-Projekt, in dem sich das aufrufende Modul befindet.<\/p>\n Manchmal kann es interessant sein, genau das VBA-Projekt zu ermitteln, das zu einem bestimmten Dokument oder einer Datenbank gehört. Voraussetzung dafür ist, dass wir den Pfad des aktuellen Dokuments kennen. Dann können wir einfach die Liste der VBA-Projekte im VBA-Editor durchlaufen und prüfen, ob der mit der Eigenschaft Filename <\/b>gelieferte Pfad mit dem Pfad des Dokuments übereinstimmt.<\/p>\n Die Auflistung VBComponents <\/b>des VBProject<\/b>-Objekts liefert alle VBComponent<\/b>-Elemente des VBA-Projekts. Im folgenden Beispiel durchlaufen wir alle Elemente und lassen uns den Namen und den Typ ausgeben:<\/p>\n Die verschiedenen Typen können wir der Enumeration vbext_ComponentType <\/b>entnehmen. Hier finden wir:<\/p>\n Für das Bearbeiten von VBA-Projekten kann es hilfreich sein, neue Module anzulegen.<\/p>\n Module sind VBComponent<\/b>-Objekt, also nutzen wir dazu die Methode Add <\/b>der VBComponents<\/b>-Auflistung.<\/p>\n Dieser übergeben wir für ein neues Standardmodul den Wert vbext_ct_StdModule <\/b>als Parameter und referenzieren das neue Modul mit der Variablen objVBComponent<\/b>. Diesem geben wir anschließend direkt einen neuen Namen:<\/p>\n Würden wir beispielsweise ein Klassenmodul erstellen wollen, ginge das mit folgender Anpassung:<\/p>\n Mit dem neuen VBComponent<\/b>-Objekt können wir noch nicht allzu viel anfangen, wenn wir seinen Code anpassen wollen. Dazu müssen wir das CodeModule<\/b>-Objekt referenzieren, dass sich hinter der gleichnamigen Eigenschaft des VBComponent<\/b>-Elements verbirgt.<\/p>\n Es gibt allerdings verschiedene Wege, ein CodeModule<\/b>-Element zu referenzieren. Der erste ist der Weg über das VBComponent<\/b>-Element, in dem sich das Modul befindet. Wenn wir den Namen des VBComponent<\/b>-Elements kennen, gelingt das beispielsweise wie folgt:<\/p>\n Um zu prüfen, ob wir das richtige CodeModule<\/b>-Element <\/b>referenziert haben, geben wir die mit der Line<\/b>-Methode ermittelten ersten zehn Zeilen des Moduls im Direktbereich des VBA-Editors aus.<\/p>\n Wenn wir wissen, dass das VBComponent<\/b>-Element mit dem gewünschten CodeModule <\/b>aktiviert ist, können wir noch schneller darauf zugreifen:<\/p>\n Hier nutzen wir ein Objekt, das wir noch nicht vorgestellt haben, auf das wir aber über die Eigenschaft ActiveCodePane <\/b>zugreifen können – das CodePane<\/b>-Objekt. Auf dieses Objekt kommen wir gleich im Anschluss zu sprechen.<\/p>\n Wichtig ist, dass dieses genau wie VBComponent <\/b>ebenfalls die Eigenschaft CodeModule<\/b> bietet, mit der wir auf das CodeModule<\/b>-Element zugreifen können.<\/p>\n Die CodeModule<\/b>-Klasse bietet uns den Großteil der Möglichkeiten, um mit dem Code zu arbeiten – einige weitere finden wir noch im CodePane<\/b>-Element.<\/p>\n Wir schauen uns nun zunächst die Möglichkeiten von CodeModule <\/b>an und kommen dann auf CodePane <\/b>zu sprechen.<\/p>\n Wenn wir die Eigenschaften und Methoden der CodeModule<\/b>-Klasse ausprobieren wollen, benötigen wir optimalerweise immer ein neues, leeres Modul. Damit wir den gleichen Code zum Erstellen dieses Moduls nicht immer wieder in die Beispielprozeduren schreiben müssen, haben wir zu diesem Zweck eine Funktion erstellt (siehe Listing 1).<\/p>\n Listing 1: Die Funktion NeuesLeeresModul<\/span><\/b><\/p>\n Die Prozedur nimmt den Namen des zu erstellenden Moduls mit dem Parameter strModulname <\/b>entgegen. Sie deklariert ein VBProject<\/b>– und ein VBComponent<\/b>-Element. Das VBProject<\/b>-Element objVBProject <\/b>füllt es mit einem Veweis auf das aktuelle VBA-Projekt.<\/p>\n Dann deaktiviert es die eingebaute Fehlerbehandlung, um das eventuell bereits vorhandene VBComponent<\/b>-Element mit dem Namen aus strModulname <\/b>zu referenzieren.<\/p>\n Ist ein solches vorhanden, ist objVBComponent <\/b>anschließend mit einem Verweis auf das entsprechende Objekt gefüllt. Dies prüfen wir durch den Vergleich mit Is Nothing<\/b>. Ist objVBComponent <\/b>nicht leer, entfernen wir es mit der Remove<\/b>-Methode aus der Auflistung VBComponents <\/b>des aktuellen Projekts.<\/p>\n Dann legen wir das Modul mit der Add<\/b>-Methode der VBComponents<\/b>-Auflistung erneut an und weisen diesem den Namen aus strModulname <\/b>zu. Schließlich geben wir den Verweis auf dieses VBComponent<\/b>-Element an die aufrufende Routine zurück.<\/p>\n Mit der oben vorgestellten Funktion NeuesLeeresModul <\/b>können wir mit zwei Zeilen ein neues Modul erstellen und mit einer CodeModule<\/b>-Variablen referenzieren:<\/p>\n Das neue Modul wird anschließend direkt geöffnet (siehe Bild 4).<\/p>\n Bild 4: Erstellen eines neuen, leeren Moduls mit zwei Zeilen<\/span><\/b><\/p>\n Die CodeModule<\/b>-Klasse bietet zwei Möglichkeiten, schnell Code einzufügen. Die erste ist die AddFromFile<\/b>-Methode.<\/p>\n Sie fügt den Inhalt der als Parameter angegebenen Textdatei hinten an den bestehenden Code des Moduls an, für dessen CodeModule<\/b>-Objekt die Methode aufgerufen wurde. Zu Testzwecken haben wir die einfache Textdatei aus Bild 5 erstellt.<\/p>\n Bild 5: Textdatei mit Beispielcode zum Einlesen<\/span><\/b><\/p>\n Dann rufen wir die folgende Prozedur auf:<\/p>\n Das Ergebnis sehen wir in Bild 6. Der Text wird also einfach hinten angefügt.<\/p>\n Bild 6: Modul mit eingefügtem Code aus einer Textdatei<\/span><\/b><\/p>\n Die zweite Möglichkeit, Code einfach hinten an den bestehenden Code eines Moduls anzufügen, ist die Methode AddFromString<\/b>. Sie erwartet ein Literal oder eine Variable, deren Inhalt zum Modul hinzugefügt wird. Im einfachsten Fall geben wir den hinzuzufügenden Code als Parameter an:<\/p>\n Wir können den Code zuvor auch in einer Variablen zusammenstellen (siehe Listing 2). Wichtig sind hier zwei Faktoren:<\/p>\n Listing 2: Hinzufügen von Code aus einer Variablen<\/span><\/b><\/p>\n Das Beispiel liefert das gleiche Modul wie das vorherige.<\/p>\n Es gibt verschiedene Funktionen, mit denen wir die Zeilen innerhalb des Moduls zählen können. Zwei stellen wir hier vor, eine weitere zählt die Zeilen einer Prozedur – diese schauen wir uns weiter unten an.<\/p>\n Die Funktion CountOfDeclarationLines<\/b> liefert die Anzahl der Deklarationszeilen des Moduls. Was bedeutet das genau? Und was sind die Deklarationszeilen?<\/p>\n Die Deklarationszeilen sind alle Zeilen, die sich vor der ersten Sub<\/b>-, Function<\/b>– oder Property<\/b>-Prozedur befunden oder, wenn keine solche Prozedur vorhanden ist, sind es alle Zeilen. Dabei gehören leere Zeilen zwischen der letzten Deklarationszeile und der ersten Zeile einer Prozedur zu der jeweiligen Prozedur. <\/p>\n Zu Demonstrationszwecken haben wir in Bild 7 Zeilennummern zum Modul hinzugefügt.<\/p>\n Bild 7: Modul mit Zeilennummern<\/span><\/b><\/p>\n Wenn wir für dieses Modul den Wert von CountOfDeclarationLines <\/b>im Direktbereich ausgeben wollen, nutzen wir folgenden Code:<\/p>\nDie Klassen und Elemente der VBE-Bibliothek<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2024_02\/pic_426_002.png\")
<\/p>\n\n
Deklarieren und Referenzieren<\/h2>\n
Dim <\/span>objWindow As <\/span>VBIDE.Window<\/pre>\nSet<\/span> objWindow = VBE.ActiveWindow<\/pre>\nFenster im VBA-Editor programmieren<\/h2>\n
Public Sub <\/span>FensterDurchlaufen()\r\n Dim <\/span>objWindow As <\/span>VBIDE.Window\r\n For Each objWindow In VBE.Windows\r\n With<\/span> objWindow\r\n Debug.Print<\/span> .Type, .WindowState, .Caption\r\n End With<\/span>\r\n Next<\/span> objWindow\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2024_02\/pic_426_003.png\")
<\/p>\nVBA-Projekte<\/h2>\n
Public Sub <\/span>ProjekteDurchlaufen()\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n For Each objVBProject In VBE.VBProjects\r\n Debug.Print<\/span> objVBProject.Name\r\n Next<\/span> objVBProject\r\nEnd Sub<\/span><\/pre>\n\n
Aktuelles VBA-Projekt ermitteln<\/h2>\n
VBA-Projekt zu einem bestimmten Dokument ermitteln<\/h2>\n
Die VBA-Komponten oder: VBComponents<\/h2>\n
<b>Public Sub KomponentenDurchlaufen()\r\n<b> Dim objVBProject As <\/span>VBIDE.VBProject\r\n<b> Dim objVBComponent As <\/span>VBIDE.VBComponent\r\n<b> Set<\/span> objVBProject = VBE.ActiveVBProject\r\n<b> For Each objVBComponent In objVBProject.VBComponents\r\n<b> Debug.Print<\/span> objVBComponent.Name, objVBComponent.Type\r\n<b> Next<\/span> objVBComponent\r\nEnd Sub<\/span><\/pre>\n\n
Neue VB-Komponente anlegen<\/h2>\n
Public Sub <\/span>NeuesModul()\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Set<\/span> objVBComponent = VBE.ActiveVBProject. _\r\n VBComponents.Add(vbext_ct_StdModule)\r\n objVBComponent.Name = \"mdlNeuesModul\"\r\nEnd Sub<\/span><\/pre>\nSet<\/span> objVBComponent = VBE.ActiveVBProject. _\r\n VBComponents.Add(vbext_ct_ClassModule)\r\nobjVBComponent.Name = \"clsNeueKlasse\"<\/pre>\nVon der Komponente zum Modul<\/h2>\n
CodeModule referenzieren<\/h2>\n
Public Sub <\/span>MitModulArbeiten()\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Set<\/span> objCodeModule = VBE.ActiveVBProject. _\r\n VBComponents(\"mdlNeuesModul\").CodeModule\r\n Debug.Print<\/span> objCodeModule.Lines(1, 10)\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>MitMarkiertemModulArbeiten()\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Set<\/span> objCodeModule = VBE.ActiveCodePane.CodeModule\r\n Debug.Print<\/span> objCodeModule.Lines(1, 10)\r\nEnd Sub<\/span><\/pre>\nMit dem Code arbeiten<\/h2>\n
\n
Ausprobieren der Eigenschaften und Methoden der CodeModule-Klasse<\/h2>\n
Public Function <\/span>NeuesLeeresModul(strModulname As String<\/span>) As <\/span>VBComponent\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n On Error Resume Next<\/span>\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModulname)\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> objVBComponent Is Nothing Then<\/span>\r\n objVBProject.VBComponents.Remove objVBComponent\r\n End If<\/span>\r\n Set<\/span> objVBComponent = objVBProject.VBComponents.Add(vbext_ct_StdModule)\r\n objVBComponent.Name = strModulname\r\n Set<\/span> NeuesLeeresModul = objVBComponent\r\nEnd Function<\/span><\/pre>\nModul anlegen<\/h2>\n
Public Sub <\/span>CodeModule_LeeresModul()\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Set<\/span> objCodeModule = _\r\n NeuesLeeresModul(\"mdlTest\"). _\r\n CodeModule\r\nEnd Sub<\/span><\/pre>\n![\"Erstellen](\"..\/fileadmin\/_temp_\/2024_02\/pic_426_005.png\")
<\/p>\nCode aus einer Datei hinzufügen<\/h2>\n
![\"Textdatei](\"..\/fileadmin\/_temp_\/2024_02\/pic_426_004.png\")
<\/p>\nPublic Sub <\/span>CodeModule_AddFromFile()\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Set<\/span> objCodeModule = _\r\n NeuesLeeresModul(\"mdlTest\").CodeModule\r\n objCodeModule.AddFromFile _\r\n CurrentProject.Path & \"\\code.txt\"\r\nEnd Sub<\/span><\/pre>\n![\"Modul](\"..\/fileadmin\/_temp_\/2024_02\/pic_426_006.png\")
<\/p>\nCode aus einem Literal oder einer Variablen hinzufügen<\/h2>\n
Public Sub <\/span>CodeModule_AddFromString()\r\n ...\r\n objCodeModule.AddFromString \"Dim strTest As String<\/span>\"\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>CodeModule_AddFromString_Variable()\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>strCode As String<\/span>\r\n Set<\/span> objCodeModule = NeuesLeeresModul(\"mdlTest\").CodeModule\r\n strCode = \"Dim strTest As String<\/span>\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n strCode = strCode & \"Public Sub Test()\" & vbCrLf<\/span>\r\n strCode = strCode & \" strTest = \"\"Beispieltext\"\"\" & vbCrLf<\/span>\r\n strCode = strCode & \" MsgBox<\/span> strTest\" & vbCrLf<\/span>\r\n strCode = strCode & \"End Sub\"\r\n objCodeModule.AddFromString strCode\r\nEnd Sub<\/span><\/pre>\n\n
Zeilen zählen<\/h2>\n
![\"Modul](\"..\/fileadmin\/_temp_\/2024_02\/pic_426_007.png\")
<\/p>\n