<\/p>\n
Access bietet nicht nur die Möglichkeit, Tabellen, Abfragen, Formulare und Berichte per VBA-Code zu erstellen. Sie können auch die Elemente, die Sie im VBA-Editor bearbeiten, per VBA erstellen, bearbeiten und wieder löschen. Dieser Beitrag macht den Start in eine Beitragsreihe, die sich mit den Möglichkeiten zur Programmierung des VBA-Editors und von VBA-Code beschäftigen. In diesem Teil schauen wir uns an, wie Sie überhaupt VBA-Projekte mit VBA referenzieren.<\/b><\/p>\nVoraussetzung: Extensibility-Verweis <\/h2>\n
Wenn Sie Routinen erschaffen wollen, mit denen Sie wiederum VBA-Elemente und -Code manipulieren möchten, benötigen Sie einen Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 Object Library<\/b>.<\/p>\n
Diesen fügen Sie im VBA-Editor mit dem Verweise<\/b>-Dialog hinzu, den Sie mit dem Menübefehl Extras|Verweise <\/b>öffnen (siehe Bild 1).<\/p>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2022_01\/pic_1337_001.png\")
<\/p>\n
Bild 1: Verweis auf die Extensibility-Bibliothek<\/span><\/b><\/p>\n Eines der praktischen Dinge an Access ist, dass sowohl die Daten als auch die Elemente der Benutzeroberfläche und die Anwendungslogik normalerweise in einer einzigen Datei stecken. Natürlich gibt es Ausnahmen, wo die Tabellen in eine Backend-Access-Datei ausgelagert wurden oder wo die Tabellen Teil einer SQL Server-Datenbank sind. Und es gibt auch noch die Möglichkeit, dass Sie in einer Datenbankanwendung Elemente aus anderen Datenbankdateien nutzen – zum Beispiel, wenn Sie VBA-Code in eine Bibliotheksdatenbank auslagern.<\/p>\n Was jedoch immer garantiert ist, dass eine Access-Datenbankdatei auch ein VBA-Projekt enthält. Das VBA-Projekt speichert dabei die Module und Klassenmodule der Datenbankanwendung, wobei es zwei Typen von Klassenmodulen gibt – alleinstehende oder solche, die zu einem Formular oder einem Bericht gehören.<\/p>\n Derweil muss nicht jedes Formular und jeder Bericht ein Klassenmodul enthalten. Ein Klassenmodul zu einem Formular oder Bericht wird von Access erst durch eine der beiden folgenden Aktionen angelegt:<\/p>\n Um das aktuelle VBA-Projekt zu referenzieren, bedarf es keiner besonderen Tricks. Wir nutzen dazu die folgende Technik, nachdem wir den Namen unseres Beispielprojekts auf prjVBAEditorProgrammieren<\/b> eingestellt haben.<\/p>\n Das erledigen Sie über den Eigenschaften<\/b>-Bereich, während Sie im Projektexplorer den Eintrag für das Projekt der aktuellen Datenbank markiert haben (siehe Bild 2).<\/p>\n Bild 2: Ändern des Namens des VBA-Projekts<\/span><\/b><\/p>\n Danach probieren Sie den folgenden Code aus:<\/p>\n Die Prozedur deklariert eine Variable des Typs VBProject<\/b> und füllt diese mit der Eigenschaft ActiveVBProject <\/b>der Klasse VBE<\/b>. Die Klasse VBE <\/b>ist das oberste Element der Bibliothek zur Programmierung des Visual Basic Editors.<\/p>\n Nachdem wir die Variable objVBProject <\/b>gefüllt haben, können wir damit beispielsweise auf den Namen des Projekts zugreifen. Diesen gibt die Prozedur im vorliegenden Fall wie in Bild 3 aus.<\/p>\n <\/p>\n Bild 3: Ausgabe des Namens des VBA-Projekts<\/span><\/b><\/p>\n Aber referenzieren wir mit der Eigenschaft ActiveVBProject <\/b>auch tatsächlich immer das VBProject<\/b>-Objekt der aktuellen Datenbank<\/p>\n Nein, das ist nicht sichergestellt. Um das zu reproduzieren, wechseln Sie einmal zum Access-Fenster und legen ein neues, leeres Formular in der Entwurfsansicht an. Dann klappen Sie im Ribbon unter Entwurf|Steuerelemente <\/b>die Liste der Steuerelemente auf und aktivieren dort die Option Steuerelement-Assistent verwenden (siehe Bild 4).<\/p>\n Bild 4: Aktivieren des Steuerelement-Assistenten<\/span><\/b><\/p>\n Danach fügen Sie beispielsweise eine neue Schaltfläche hinzu, was den dazugehörigen Assistenten aktiviert. Das war es schon auf der Access-Seite – Sie können den Assistenten nun abbrechen und wieder zum VBA-Editor wechseln.<\/p>\n Hier finden Sie nun plötzlich zwei VBA-Projekte vor – zusätzlich zu dem der aktuellen Access-Datenbank finden Sie noch das VBA-Projekt acwzmain <\/b>vor (siehe Bild 5). Dabei handelt es sich um das VBA-Projekt der Add-In-Datenbank mit dem Assistenten zum Erstellen der Schaltfläche, den Sie soeben verwendet haben.<\/p>\n Bild 5: Der Projektexplorer zeigt nun zwei VBA-Projekte an.<\/span><\/b><\/p>\n Sobald Sie also einen Assistenten nutzen, wird dessen VBA-Projekt ebenfalls im VBA-Editor mit dem VBA-Projekt der aktuellen Datenbank eingeblendet.<\/p>\n Es gibt also nun mehr als ein VBA-Projekt. Wird das zum Problem, wenn wir das aktuelle Projekt mit der Eigenschaft VBE.ActiveVBProject.Name <\/b>abrufen Nein, denn Sie erhalten immer den Verweis auf das VBA-Projekt des Projekts, von dem aus Sie die Eigenschaft der VBE-Klasse aufrufen.<\/p>\n Und da sich unsere Prozedur VBProjectReferenzieren <\/b>im Projekt der aktuellen Datenbank befindet, liefert diese auch immer das Projekt der aktuellen Datenbank.<\/p>\n Es gibt jedoch einen Umstand, in dem das nicht gewünscht ist und wo Sie eine andere Datenbank referenzieren wollen: Nämlich dann, wenn die von Ihnen programmierte Datenbank selbst eine Add-In-Datenbank ist, mit der Sie auf das VBA-Projekt der Datenbank zugreifen wollen, von der aus Sie das Access-Add-In geöffnet haben.<\/p>\n Dann liefert VBE.ActiveVBProject.Name <\/b>nämlich den Namen des VBA-Projekts der Add-In-Datenbank.<\/p>\n Wenn Sie das Add-In allerdings beispielsweise dazu nutzen wollen, um den Code der Datenbank, von der aus das Add-In aufgerufen wurde, zu ändern, dann benötigen Sie einen Verweis auf deren VBA-Projekt.<\/p>\n Um überhaupt auf alle VBA-Projekte zuzugreifen, können Sie alle VBProject<\/b>-Elemente mit einer For Each<\/b>-Schleife über die Auflistung VBProjects <\/b>der VBE<\/b>-Klasse durchlaufen:<\/p>\n Diese Prozedur gibt den Namen aller VBProject<\/b>-Elemente aus, die aktuell im VBA-Editor aufgelistet werden, in diesem Fall also beispielsweise:<\/p>\n Die Frage ist nun: Wie können wir vom VBA-Projekt der Add-In-Datenbank aus das VBProject<\/b>-Element referenzieren, das zu der aktuell geöffneten Access-Datenbank gehört Mit ActiveVBProject <\/b>gelingt das nicht, denn dieses greift dann auf das VBProject<\/b>-Element der Add-In-Datenbank zu.<\/p>\n Es gibt jedoch einen einfachen Trick, mit dem wir die richtige Datenbank referenzieren. Und nein: Wir schauen nicht, welches der beiden VBA-Projekte nicht das der Add-In-Datenbank ist und somit das VBA-Projekt der aktuell geöffneten Datenbank sein muss. Denn es könnte auch sein, dass der Benutzer seit dem Starten von Access noch ein anderes Add-In geöffnet hat, und somit gleich drei oder noch mehr VBA-Projekte im Projektexplorer angezeigt werden.<\/p>\n Die Lösung sieht wie folgt aus:<\/p>\n Die Funktion durchläuft wieder alle VBProject<\/b>-Elemente der Auflistung VBProjects<\/b>. Es vergleicht für jedes den Wert der Eigenschaft FileName <\/b>mit der Eigenschaft Name <\/b>des CurrentDb<\/b>-Objekts. CurrentDb <\/b>liefert immer einen Verweis auf das Database<\/b>-Objekt der aktuell in Access geöffneten Access-Datenbank und niemals den für eine als Add-In geöffneten Datenbank.<\/p>\n Wenn Sie das Database<\/b>-Objekt eines Add-Ins vom VBA-Projekt der Add-In-Datenbank aus ermitteln wollen, verwenden Sie dazu die Funktion CodeDb<\/b>.<\/p>\n Und wenn der Dateiname des aktuell durchlaufenen VBA-Projekts mit dem Dateinamen der aktuell in Access geöffneten Datenbank übereinstimmt, handelt es sich auch um das VBA-Projekt dieser Datenbank.<\/p>\n Der Einsatz dieser Funktion ist nur sinnvoll, wenn Sie diese innerhalb eines Add-Ins einsetzen. Direkt im VBA-Projekt einer Datenbank ist es einfacher, direkt VBE.ActiveVBProject <\/b>zu nutzen.<\/p>\n Wenn Sie die Elemente von VBA-Projekten per VBA programmieren wollen, benötigen Sie auf jeden Fall einen Verweis auf das VBProject<\/b>-Element des betroffenen VBA-Projekts.<\/p>\n Darüber können Sie dann beispielsweise auf die Elemente des VBA-Projekts wie die Standardmodule und Klassenmodule zugreifen, um diese neu anzulegen, zu bearbeiten oder zu löschen oder auch um deren Inhalte zu manipulieren.<\/p>\n Im Beitrag Zugriff auf VBA-Projekte per VBProject <\/b>(www.access-im-unternehmen.de\/1351<\/b>) zeigen wir, welche Möglichkeiten die VBProject<\/b>-Klasse bietet. <\/p>\n Enthaltene Beispieldateien:<\/p>\n VBAEditorProgrammieren.accdb<\/p>\nAccess-Datenbank und VBA-Projekt<\/h2>\n
\n
Aktuelles VBA-Projekt referenzieren<\/h2>\n
![\"Ändern](\"..\/fileadmin\/_temp_\/2022_01\/pic_1337_002.png\")
<\/p>\nPublic Sub <\/span>VBProjectReferenzieren()\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Debug.Print<\/span> objVBProject.Name\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2022_01\/pic_1337_003.png\")
<\/p>\nMehrere VBA-Projekte im VBA-Editor<\/h2>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2022_01\/pic_1337_004.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2022_01\/pic_1337_005.png\")
<\/p>\nVBProject-Elemente durchlaufen<\/h2>\n
Public Sub <\/span>ProjekteDurchlaufen()\r\n Dim <\/span>objVBProject As <\/span>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>\nprjVBAEditorProgrammieren\r\nacwzmain<\/pre>\n
VBA-Projekt der aktuell geöffneten Datenbank ermitteln<\/h2>\n
Public Function <\/span>GetVBProjectOfCurrentDb() As <\/span>VBProject\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n For Each objVBProject In VBE.VBProjects\r\n If <\/span>objVBProject.FileName = CurrentDb.Name Then<\/span>\r\n Set<\/span> GetVBProjectOfCurrentDb = objVBProject\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> objVBProject\r\nEnd Function<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n