{"id":55000467,"date":"2019-12-01T00:00:00","date_gmt":"2020-03-23T18:48:59","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=467"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Erweitern_der_VBAIDE_Mit_Code_arbeiten","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Erweitern_der_VBAIDE_Mit_Code_arbeiten.html","title":{"rendered":"Erweitern der VBA-IDE: Mit Code arbeiten"},"content":{"rendered":"

Die Visual Basic-Entwicklungsumgebung ist definitiv in die Jahre gekommen. Wer schon einmal mit einer modernen Entwicklungsumgebung wie Eclipse oder dem Visual Studio .NET gearbeitet hat, wird bei der Rückkehr zur VBA-IDE möglicherweise einiges vermissen. Es gibt aber Möglichkeiten, die Entwicklungsumgebung zu erweitern – sogar mit den Hausmitteln von Access und mit nur zwei zusätzlichen Bibliotheken. Im zweiten Teil dieser Artikelreihe schauen wir uns an, wie Sie per Code mit dem VBA-Code des VBA-Projekts arbeiten.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels finden Sie in der Datenbank 1906_Entwicklungsumgebung_Code.accdb<\/b>.<\/p>\n

Einstieg<\/h2>\n

Was ließen sich nicht für tolle Funktionen für die VBA-Entwicklungsumgebung umsetzen: Automatisches Hinzufügen oder Entfernen von Code, Kommentarzeichen oder Nummerierungen, automatisches Anlegen von Klassen oder Modulen, Erweitern von Prozeduren um Fehlerbehandlungen und vieles mehr. Der Haken an der Sache ist: Wie programmiert man das, und wie soll man die Funktionen anschließend aufrufen<\/p>\n

Grundlage für all diese Techniken ist das Objektmodell der Visual Basic-Entwicklungsumgebung (kurz: VBE). Die Grundlagen dazu haben wir bereits im ersten Teil dieser Artikelreihe betrachtet (siehe Erweitern der VBA-IDE: Mit Modulen<\/b>). Sie bietet noch eine ganze Reihe von Möglichkeiten mehr: Sie können damit den Quellcode direkt manipulieren, Codepassagen suchen und ersetzen, Zeilen von Modulen und Prozeduren zählen oder die Prozeduren eines Moduls ermitteln.<\/p>\n

Das ist alles schön und gut, aber was hilft es, wenn man die notwendigen Routinen zur Codemanipulation nur auf herkömmlichem Wege, also etwa per Direktfenster oder über die Schaltflächen eines Formulars, aufrufen kann Im letzteren Fall müsste man dazu sogar noch von der VBE zur Access-Oberfläche wechseln.<\/p>\n

Und wer schon einmal versucht hat, über das VBE-Objektmodell einfach eine Menüleiste anzulegen und über die OnAction<\/b>-Methode eines CommandBarButton<\/b>-Objekts eine entsprechende Funktion zu starten, musste feststellen, dass dies leider nicht funktioniert.<\/p>\n

Der vorliegende Beitrag beschäftigt sich sowohl mit den zur Manipulation von VBA-Modulen notwendigen Objekten, Methoden und Eigenschaften des VBE-Objektmodells als auch mit einem Trick, mit dem Sie den benutzerdefinierten Menüleisten in der VBA-Entwicklungsumgebung doch noch etwas abgewinnen.<\/p>\n

Voraussetzungen für den Zugriff auf VBA-Module<\/h2>\n

Bevor es an das Programmieren geht, müssen Sie noch zwei Verweise einstellen: Neben den üblichen Verdächtigen sind das die Bibliotheken Microsoft Visual Basic forApplications Extensibility x.y <\/b>und Microsoft Office x.y Object Library <\/b>(siehe Bild 1). Erstere stellt das VBE-Objektmodell und Letztere die für das Anlegen von Menüs im VBA-Editor notwendigen Objekte bereit — dazu später mehr.<\/p>\n

\"Notwendiger<\/a><\/p>\n

Bild 1: Notwendiger Verweis für das Programmieren der VBA-Entwicklungsumgebung<\/p>\n

Code bearbeiten mit dem VBE-Objektmodell<\/h2>\n

Einige Informationen über die Handhabung von Modulen können Sie dem bereits weiter oben angegebenen Artikel entnehmen.<\/p>\n

Im vorliegenden Artikel finden Sie Informationen über die Befehle, die sich mit dem Inhalt der Module beschäftigen – mit dem Code selbst. Dabei erfahren Sie, wie Sie die Methoden und Eigenschaften der VBE-Objektbibliothek verwenden, um den Code zu manipulieren.<\/p>\n

Aus Platzgründen finden Sie hier keine komplette Vorstellung aller Objekte, Methoden und Eigenschaften. Wenn Sie weitere Informationen benötigen, schauen Sie sich einfach im Objektkatalog um und wählen dort die gewünschte Objektbibliothek aus (siehe Bild 2).<\/p>\n

\"überblick<\/a><\/p>\n

Bild 2: überblick über die VBE-Objektbibliothek<\/p>\n

Moduleigenschaften erkunden<\/h2>\n

Legen Sie doch einfach mit ein paar Fingerübungen los und erkunden Sie die Eigenschaften eines Moduls. Dabei lernen Sie direkt, welche davon sich dazu eignen, einzelne Prozeduren oder den Deklarationsbereich eines Moduls zu extrahieren – die einzelnen Elemente sind nämlich nicht über eine Auflistung oder ähnliches auszuwählen, sondern müssen mühsam von Hand erfasst werden.<\/p>\n

Zielmodul festlegen<\/h2>\n

Als Erstes müssen Sie im Code das Modul referenzieren, das Sie untersuchen möchten.<\/p>\n

Zwei Möglichkeiten sind für die nachfolgenden Beispiele interessant: Das aktuelle Modul steht im Mittelpunkt des Interesses, oder Sie wählen das gewünschte Modul explizit aus.<\/p>\n

In beiden Fällen deklarieren Sie zunächst eine Variable, mit der Sie das Zielmodul referenzieren:<\/p>\n

Dim <\/span>objCodeModule As <\/span>CodeModule<\/pre>\n
Mit folgender Anweisung setzen Sie die Objektvariable auf das Codemodule im aktuellen Codepane:<\/p>\n
Set<\/span> objCodeModule = VBE.ActiveCodePane.CodeModule<\/pre>\n
Für ein anderes, bestimmtes Modul verwenden Sie die folgende Zuweisung:<\/p>\n
Set<\/span> objCodemodule = VBE.ActiveVBProject._\r\n    VBComponents.Item(\"mdlVBEBeispiele\").CodeModule<\/pre>\n
Zum Durchlaufen aller enthaltenen Codemodule verwenden Sie die Auflistung aller VBComponents<\/b> in einer For Each<\/b>-Schleife. Die Routine aus Listing 1 gibt den Inhalt aller vorhandenen Module im Direktfenster aus.<\/p>\n
<font color=blue>Public Function <\/font>A11eModuleAusgeben()\r\n     <font color=blue>Dim <\/font>objVBComponent<font color=blue> As <\/font>VBComponent\r\n     <font color=blue>Dim <\/font>objCodeModule<font color=blue> As <\/font>CodeModule\r\n     For Each objVBComponent In VBE.ActiveVBProject.VBComponents\r\n         <font color=blue>Debug.Print<\/font> \"======================================\"\r\n         <font color=blue>Debug.Print<\/font> objVBComponent.Name\r\n         <font color=blue>Debug.Print<\/font> \"======================================\"\r\n         <font color=blue>Set<\/font> objCodeModule = objVBComponent.CodeModule\r\n         <font color=blue>Debug.Print<\/font> objCodeModule.Lines(1, objVBComponent.CodeModule.CountOfLines)\r\n     <font color=blue>Next<\/font> objVBComponent\r\nEnd Function<\/span><\/pre>\n
Listing 1:  Ausgabe aller Module inklusive Namen im Direktfenster<\/p>\n
Zeilen zählen<\/h2>\n
Die oben beschriebene Routine verwendet bereits die Eigenschaft CountOfLines <\/b>des CodeModule<\/b>-Objekts.<\/p>\n
Diese Eigenschaft gibt die Gesamtanzahl der Zeilen eines Moduls aus – so lässt sich die Line<\/b>-Eigenschaft mit der Nummer der ersten Zeile und der Anzahl der Zeilen füttern, um alle enthaltenen Zeilen auszugeben.<\/p>\n
Etwas weniger Zeilen gibt die Eigenschaft Count-Of-DeclarationLines <\/b>aus. Sie zählt die Zeilen bis zur letzten Zeile des Deklarationsbereichs. Wenn der Deklarationsbereich eines Moduls nur aus den folgenden beiden Zeilen besteht, gibt die Funktion CountOfDeclarationLines <\/b>den Wert 2 <\/b>aus:<\/p>\n
Option Compare Database<\/span>\r\nOption Explicit<\/span><\/pre>\n
Um diese und die nachfolgend vorgestellten Methoden und Eigenschaften zu testen, legen Sie am besten ein Beispielmodul wie in Bild 3 an. Wichtig sind dabei die per Kommentar angegebenen Zeilennummern.<\/p>\n
\"Beispielmodul<\/a><\/p>\n
Bild 3: Beispielmodul zum Ausprobieren der VBE-Funktionen<\/p>\n
Prozeduren untersuchen<\/h2>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t