Im Artikel “VBA: Early Binding und Late Binding” (www.vbentwickler.de\/4) haben wir die beiden Methoden Early Binding und Late Binding vorgestellt und ihre Vor- und Nachteile beschrieben. Im vorliegenden Artikel zeigen wir nun eine automatische Lösung, um schnell einige oder alle per Early Binding definierten Elemente nach Late Binding zu migrieren. Dazu nutzen wir Code, der zunächst alle Early Binding-Elemente ermittelt, diese in einem Formular anzeigt und es dann ermöglicht, diese in Late Binding-Elemente umzuwandeln. <\/b><\/p>\n
Die Lösung aus diesem Artikel soll es ermöglichen, alle Module der aktuellen Datenbank aus einem Listenfeld auszuwählen und alle dort in Deklarationszeilen vorhandenen Klassen, Typen und Enumerationen einzulesen.<\/p>\n
Wir benötigen zwar die Typen und Enumerationen nicht, da wir diese nicht nach Late Binding migrieren können, aber aus technischen Gründen können wir diese nicht ohne erheblichen Aufwand aus der Ermittlung ausschließen. <\/p>\n
Das Formular zur Steuerung dieses Vorgangs sehen wir in Bild 1. Hier haben wir das Modul mdlTest <\/b>ausgewählt und anschließend auf die Schaltfläche Typen einlesen <\/b>geklickt, um alle dort enthaltenen Typen zu ermitteln und in einem weiteren Listenfeld anzuzeigen.<\/p>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2025_06\/pic_495_001.png\")
<\/p>\n
Bild 1: Formular zum Steuern der Migration nach Late Binding<\/span><\/b><\/p>\n Wenn wir nun einen oder mehrere dieser Einträge markieren und auf die Schaltfläche Early Binding ersetzen klicken, werden die als Early Binding deklarierten Elemente samt der zur Initialisierung verwendeten Anweisungen in Late Binding umgewandelt – und zwar in allen Modulen, die im oberen Listenfeld markiert sind.<\/p>\n Zusätzlich finden wir dort noch ein Kontrollkästchen namens Ersetzte Zeilen als Kommentar behalten<\/b>. Damit können wir festlegen, dass die Early Binding-Anweisungen nicht gelöscht, sondern lediglich auskommentiert werden.<\/p>\n Im Beispielmodul mdlTest <\/b>haben wir einige mit Early Binding versehene Anweisungen untergebracht – und zwar in den unterschiedlichsten Ausprägungen:<\/p>\n Bild 2: Beispielanweisungen mit Early Binding<\/span><\/b><\/p>\n<\/ul>\n Nachdem wir die beiden Typen ADODB.Connection <\/b>und ADODB.Recordset <\/b>mit unserem Formular umgestellt haben, sieht der abgebildete Ausschnitt des Moduls wie in Bild 3 aus.<\/p>\n Bild 3: Beispielanweisungen mit Late Binding und auskommentierter Early Binding-Version<\/span><\/b><\/p>\n Im Formular finden wir in der Entwurfsansicht die folgenden Steuerelemente (siehe Bild 4):<\/p>\n Bild 4: Das Formular frmEarlyBindingToLateBinding in der Entwurfsansicht<\/span><\/b><\/p>\n Beim Laden des Formulars wird das Ereignis aus Listing 1 ausgelöst. Es referenziert die aktuelle Datenbank mit der CodeDb<\/b>-Funktion (dies ist eine Vorbereitung, um die Lösung als Add-In zu nutzen). Dann löscht es die beiden Tabellen tblModules <\/b>und tblTypes<\/b>, in denen wir die ermittelten Daten speichern, um sie in den Listenfeldern anzuzeigen. tblModules <\/b>enthält das Primärschlüsselfeld ModulID <\/b>und das Textfeld Modul<\/b>. Die Tabelle tblTypes <\/b>enthält die beiden Felder TypeID <\/b>und Type <\/b>sowie Line <\/b>und LineNumber<\/b>, um jeweils eine Zeile zu speichern, in der dieser Typ auftritt (diese wurden eher zu Testzwecken während der Programmierung der Lösung genutzt).<\/p>\n Listing 1: Ereignisprozedur, die beim Laden des Formulars ausgelöst wird<\/span><\/b><\/p>\n Danach holen wir mit der Funktion CurrentVBProject <\/b>einen Verweis auf das VBA-Projekt der aktuellen Datenbank. Dies ist notwendig, da beim Vorhandensein von Access-Add-Ins oder eingebundenen Bibliotheksdatenbanken sonst gegebenenfalls das falsche VBA-Projekt verwendet wird. Die Funktion CurrentVBProject <\/b>sieht wie folgt aus:<\/p>\n Sie durchläuft alle vorhandenen VB-Projekte und prüft, ob der Pfad dem Pfad der aktuell geöffneten Access-Datenbank entspricht. Ist das der Fall, wird der Verweis auf dieses VB-Projekt zurückgegeben.<\/p>\n Für die Verwendung dieser und anderer nachfolgend genutzter Elemente, die auf den VBA-Editor und seine Module zugreifen, fügen wir dem VBA-Projekt einen Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 Object Library <\/b>hinzu.<\/p>\n Die Prozedur Form_Load <\/b>durchläuft nun alle Elemente der Auflistung VBComponents<\/b>, was den Modulen entspricht. Für jedes Modul wird ein Eintrag in der Tabelle tblModules <\/b>angelegt. Danach werden die beiden Listenfelder lstModules <\/b>und lstTypes <\/b>aktualisiert, damit sie den aktuellen Inhalt der beiden Tabellen tblModules <\/b>und tblTypes <\/b>anzeigen.<\/p>\n Schließlich haben wir noch den Fall vorbereitet, dass das Formular direkt für ein bestimmtes Modul aufgerufen wird. Dann würden wir das Argument OpenArgs mit dem Namen des gewünschten Moduls füllen. Dies wird dann direkt im Listenfeld lstModules markiert.<\/p>\n Der Aufruf des Formulars für diesen Fall sieht wie folgt aus:<\/p>\n Um alle Module auszuwählen, klicken wir auf die Schaltfläche cmdAlleTypenAuswaehlen<\/b>. Diese durchläuft alle Elemente des Listenfeldes und stellt die Eigenschaft Selected <\/b>für den jeweiligen Index auf True <\/b>ein:<\/p>\n Ein Klick auf die Schaltfläche cmdTypenEinlesen <\/b>soll alle Typen der markierten Module ermitteln und in die Tabelle tblTypes <\/b>schreiben.<\/p>\n Dazu referenziert sie wieder die Datenbank mit dem Formular und leert die Tabelle tblTypes<\/b>. Dann prüft sie, ob überhaupt Einträge im Listenfeld lstModules <\/b>markiert sind, und weist darauf hin, falls das nicht der Fall ist.<\/p>\n Danach durchläuft sie alle markierten Einträge des Listenfeldes lstModules <\/b>über die ItemsSelected<\/b>-Auflistung und ermittelt mit Column(1, var) <\/b>den Namen des jeweiligen Moduls. Innerhalb der Schleife ruft sie für jedes dieser Elemente die Prozedur TypesToTable<\/b> auf und übergibt dieser den Namen des Moduls. Schließlich aktualisiert sie die Liste der Typen.<\/p>\n Die Prozedur TypesToTable <\/b>referenziert wieder die Code-Datenbank und das aktuelle VBA-Projekt (siehe Listing 2).<\/p>\n Listing 2: Einlesen der Typen (Teil 1)<\/span><\/b><\/p>\n Danach füllt sie die Variable objVBComponent <\/b>mit einem Verweis auf das übergebene Modul und holt einen weiteren Verweis auf das enthaltene CodeModule<\/b>-Objekt, das in objCodeModule <\/b>landet.<\/p>\n Dann durchläuft sie in einer For…Next<\/b>-Schleife alle Codezeilen, wobei die letzte Zeile mit der Eigenschaft CountOfLines <\/b>ermittelt wird.<\/p>\n Hier speichert sie die Originalzeile in strLineOriginal <\/b>und in strLine <\/b>die um führende und folgende Leerzeichen bereinigte Version der Zeile.<\/p>\n Für diese ruft sie nun die Funktion KommentarAbschneiden <\/b>auf, die wir ebenfalls im Modul finden und die alle am Ende der Zeile befindlichen Kommentare aus strLine <\/b>entfernt.<\/p>\n Eine weitere Funktion namens TextAusLiteralenEntfernen <\/b>leert eventuell in Anführungszeichen vorhandene Texte. Aus der Zeile strText = “Beispieltext” <\/b>wird dann zum Beispiel strText = “”<\/b>.<\/p>\n Dies dient der Vereinfachung, damit eventuell in Literalen enthaltene Bezeichnungen der gesuchten Typen nicht berücksichtigt werden. Die Ersetzung schlägt sich nicht auf die späteren Änderungen nieder.<\/p>\n Danach steigen wir in eine Select Case<\/b>-Bedingung ein, die verschiedene Aspekte überprüft (siehe Listing 3). Der erste Case<\/b>-Zweig prüft, ob die Anweisung der aktuellen Zeile mit Const<\/b>, Public Const <\/b>oder Private Const <\/b>beginnt. Solche Zeilen sollen nicht berücksichtigt werden, da Konstanten keine der für uns interessanten Typen aufnehmen können.<\/p>\n Listing 3: Einlesen der Typen (Teil 2)<\/span><\/b><\/p>\n Der zweite Case-Zweig bearbeitet alle übrigen Zeilen, wo wir als Erstes eventuell auf mehrere Zeilen aufgeteilte Anweisungen in eine Zeile schreiben. Aus <\/p>\n wird dann beispielsweise<\/p>\n Dazu holen wir uns als Erstes die Nummer der aktuellen Zeile und speichern diese in lngProcLine<\/b>. Solange die Zeile mit dem Unterstrich endet und die Anweisung somit in der nächsten Zeile fortgesetzt wird, erhöhen wir lngProcLine <\/b>um den Wert 1 <\/b>und lesen den Teil der Zeile vor dem Unterstrich in strLine <\/b>ein. Aus <\/p>\n wird somit die folgende Zeile:<\/p>\n Dann fügen wir den Inhalt der folgenden Zeile zu strLine <\/b>hinzu. Diesen Vorgang wiederholen wir, bis die letzte Zeile der Anweisung erreicht ist. Später stellen wir lngLine auf lngProcLine <\/b>ein, damit die Zeilenfortsetzungen nicht erneut eingelesen werden.<\/p>\n Nun untersuchen wir weitere Aspekte. Zunächst prüfen wir, ob die Zeile das Schlüsselwort As <\/b>enthält. Nur in diesem Fall kann überhaupt eine Deklaration für einen Typ vorliegen.<\/p>\n Als Nächstes prüfen wir, ob es sich bei der aktuellen Zeile um eine einfache Deklaration oder um einen Prozedurkopf handelt. Dazu ermitteln wir mit der Funktion ProcOfLine<\/b>, ob sich die aktuelle Zeile innerhalb einer Prozedur befindet. In diesem Fall liefert die Funktion den Namen der Prozedur zurück, den wir in strProc <\/b>speichern. Ist strProc <\/b>nicht leer, befindet sich die Zeile innerhalb einer Prozedur. Um herauszufinden, ob es sich bei der Zeile um den Prozedurkopf handelt, ermitteln wir mit ProcBodyLine <\/b>die Nummer der Zeile, in der sich der Prozedurkopf der aktuellen Prozedur befindet. Ist strProc <\/b>leer, handelt es sich um eine Prozedurkopf-ähnliche Anweisung, etwa ein Event oder eine API-Deklaration. Auch diese wollen wir wie einen Prozedurkopf behandeln und speichern auch hier die Zeilennummer in lngProc<\/b>.<\/p>\n Wenn die aktuelle Zeile aus lngLine <\/b>nun dem Wert aus lngProc <\/b>entspricht, handelt es sich um einen Prozedurkopf oder eine Event<\/b>– oder Declare<\/b>-Anweisung.<\/p>\n In diesem Fall rufen wir eine weitere Prozedur namens ProzedurparameterVerarbeiten <\/b>auf und übergeben die relevanten Parameter. Diese Prozedur beschreiben wir im Anschluss. Außerdem rufen wir noch die Prozedur RueckgabewertVerarbeiten <\/b>auf, denn auch die Rückgabewerte einer Prozedur können Typen enthalten, die wir umwandeln wollen.<\/p>\n Ist es keine Prozedurkopfzeile, handelt es sich um eine Deklarationszeile. Dies prüfen wir noch, indem wir untersuchen, ob die ersten Zeichen der Anweisung Dim<\/b>, Public <\/b>oder Private <\/b>lauten. In diesem Fall rufen wir die Prozedur DeklarationenVerarbeiten <\/b>auf.<\/p>\n Auf diese Weise haben wir nun alle Anweisungen auf Typen untersucht. In den aufgerufenen Prozeduren werden die Typen in die Tabelle tblTypes <\/b>eingetragen.<\/p>\n Wir schauen uns diese Verarbeitung beispielhaft an der Prozedur DeklarationenVerarbeiten<\/b> an (siehe Listing 4).<\/p>\n\n
![\"Beispielanweisungen](\"..\/fileadmin\/_temp_\/2025_06\/pic_495_002.png\")
<\/p>\n![\"Beispielanweisungen](\"..\/fileadmin\/_temp_\/2025_06\/pic_495_003.png\")
<\/p>\nBeschreibung des Formulars<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2025_06\/pic_495_004.png\")
<\/p>\n\n
Ereignis beim Laden des Formulars<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n \r\n Set<\/span> db = CodeDb\r\n db.Execute \"DELETE * FROM tblModules\", dbFailOnError\r\n db.Execute \"DELETE * FROM tblTypes\", dbFailOnError\r\n \r\n Set<\/span> objVBProject = CurrentVBProject\r\n For Each objVBComponent In objVBProject.VBComponents\r\n db.Execute \"INSERT INTO tblModules(Modul) VALUES(''\" & objVBComponent.name & \"'')\", dbFailOnError\r\n Next<\/span> objVBComponent\r\n \r\n Me.lstModules.Requery\r\n Me.lstTypes.Requery\r\n \r\n If <\/span>Not<\/span> IsNull(Me.OpenArgs) Then<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strVBComponent As String<\/span>\r\n strVBComponent = Me.OpenArgs\r\n For i = 0 To Me.lstModules.ListCount - 1\r\n If <\/span>Me.lstModules.Column(1, i) = strVBComponent Then<\/span>\r\n Me.lstModules.Selected(i) = True<\/span>\r\n Call<\/span> cmdTypenEinlesen_Click\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>CurrentVBProject() As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n For Each objVBProject In VBE.VBProjects\r\n If <\/span>objVBProject.FileName = CurrentDb.Name Then<\/span>\r\n Set<\/span> CurrentVBProject = objVBProject\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> objVBProject\r\nEnd Function<\/span><\/pre>\nDoCmd.OpenForm \"frmEarlyBindingToLateBinding\", _ OpenArgs:=\"mdlTest\"<\/pre>\n
Auswählen aller Module<\/h2>\n
Private Sub <\/span>cmdAlleTypenAuswaehlen_Click()\r\n Dim <\/span>lngItem As Long<\/span>\r\n For lngItem = 0 To Me.lstTypes.ListCount - 1\r\n Me.lstTypes.Selected(lngItem) = True<\/span>\r\n Next<\/span> lngItem\r\nEnd Sub<\/span><\/pre>\nEinlesen der Typen der markierten Module<\/h2>\n
Private Sub <\/span>cmdTypenEinlesen_Click()\r\n Dim <\/span>var As Variant<\/span>\r\n Dim <\/span>strModule As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n \r\n Set<\/span> db = CodeDb\r\n DoCmd.Hourglass True<\/span>\r\n db.Execute \"DELETE * FROM tblTypes\", dbFailOnError\r\n \r\n If <\/span>Me.lstModules.ItemsSelected.Count = 0 Then<\/span>\r\n MsgBox<\/span> \"Markiere die zu untersuchenden Module.\", _\r\n vbOKOnly + vbExclamation, \"Kein Modul markiert\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n \r\n For Each var In Me.lstModules.ItemsSelected\r\n strModule = Me.lstModules.Column(1, var)\r\n Call<\/span> TypesToTable(strModule)\r\n Next<\/span> var\r\n Me.lstTypes.Requery\r\n DoCmd.Hourglass False<\/span>\r\nEnd Sub<\/span><\/pre>\nAuslesen der Typen eines Moduls<\/h2>\n
Public Sub <\/span>TypesToTable(strModule As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodeModule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>strLine As String<\/span>\r\n Dim <\/span>strProc As String<\/span>\r\n Dim <\/span>lngProcType As Long<\/span>\r\n Dim <\/span>lngProcBodyLine As Long<\/span>\r\n Dim <\/span>strLineOriginal As String<\/span>\r\n Dim <\/span>lngLine As Long<\/span>\r\n Dim <\/span>lngProcline As Long<\/span>\r\n \r\n Set<\/span> db = CodeDb\r\n \r\n Set<\/span> objVBProject = CurrentVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(strModule)\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n For lngLine = 1 To objCodeModule.CountOfLines\r\n strLineOriginal = objCodeModule.Lines(lngLine, 1)\r\n strLine = Trim<\/span>(strLineOriginal)\r\n strLine = KommentarAbschneiden(strLine)\r\n strLine = TextAusLiteralenEntfernen(strLine)\r\n ...<\/pre>\n ...\r\n Select Case True<\/span>\r\n Case <\/span>Left<\/span>(strLine, 5) = \"Const\", Left<\/span>(strLine, 12) = \"Public Const\", Left<\/span>(strLine, 13) = \"Private Const\"\r\n Case Else<\/span>\r\n lngProcline = lngLine\r\n Do While<\/span> Right<\/span>(strLine, 1) = \"_\"\r\n lngProcline = lngProcline + 1\r\n strLine = Left<\/span>(strLine, Len<\/span>(strLine) - 1)\r\n strLine = strLine & Trim<\/span>(objCodeModule.Lines(lngProcline, 1))\r\n Loop<\/span>\r\n If <\/span>Not<\/span> InStr<\/span>(1, strLine, \" As <\/span>\") = 0 Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strLine) = 0 Then<\/span>\r\n strProc = \"\"\r\n strProc = objCodeModule.ProcOfLine(lngLine, lngProcType)\r\n If <\/span>Not<\/span> Len<\/span>(strProc) = 0 Then<\/span>\r\n lngProcBodyLine = objCodeModule.ProcBodyLine(strProc, lngProcType)\r\n Else<\/span>\r\n If Split<\/span>(strLine, \" \")(0) = \"Event\" Or Split<\/span>(strLine, \" \")(1) = \"Event\" _\r\n Or Split<\/span>(strLine, \" \")(0) = \"Declare\" Or Split<\/span>(strLine, \" \")(1) = \"Declare\" Then\r\n lngProcBodyLine = lngLine\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>lngProcBodyLine = lngLine Then<\/span>\r\n Call<\/span> ProzedurparameterVerarbeiten(db, strLine, strLineOriginal, lngLine)\r\n Call<\/span> RueckgabewertVerarbeiten(db, strLine, strLineOriginal, lngLine)\r\n Else<\/span>\r\n Select Case True<\/span>\r\n Case <\/span>Left<\/span>(strLine, 3) = \"Dim\", Left<\/span>(strLine, 6) = \"Public\", Left<\/span>(strLine, 7) = \"Private\"\r\n Call<\/span> DeklarationenVerarbeiten(db, strLine, strLineOriginal, lngLine)\r\n End Select<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n lngLine = lngProcline\r\n End Select<\/span>\r\n DoEvents\r\n Next<\/span> lngLine\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>TestParameterCrLf( _\r\n rst As <\/span>ADODB.Recordset)<\/pre>\nPublic Sub <\/span>TestParameterCrLf(rst As <\/span>ADODB.Recordset)<\/pre>\nPublic Sub <\/span>TestParameterCrLf( _<\/pre>\nPublic Sub <\/span>TestParameterCrLf(<\/pre>\nDeklarationszeilen analysieren<\/h2>\n
Public Function <\/span>DeklarationenVerarbeiten(db As <\/span>DAO.Database, strLine As String<\/span>, strLineOriginal As String<\/span>, _\r\n lngLine As Long<\/span>) As String<\/span>\r\n Dim <\/span>intDeclaration As Integer<\/span>\r\n Dim <\/span>strDeclarations() As String<\/span>\r\n