<\/p>\n
Eine umfangreiche Access-Anwendung kann in ihrem VBA-Projekt einige API-Deklarationen enthalten. Je länger diese Anwendung bereits entwickelt wird, desto mehr solcher Deklarationen haben sich im Laufe der Zeit in vielen verschiedenen Modulen angesammelt. Und umso mehr dieser APIs werden vielleicht gar nicht mehr verwendet, weil man sie grundsätzlich nicht mehr braucht oder sie durch andere Funktionen oder DLLs ersetzt hat. Daher ist es grundsätzlich interessant, nicht mehr verwendete Deklarationen von API-Funktionen aus der Anwendung zu entfernen. Noch interessanter wird dies, wenn die Migration einer für 32-Bit-Access ausgelegten Anwendung zu einer Anwendung ansteht, die auch unter 64-Bit-Access ihren Dienst tun soll. Je weniger API-Funktionen dann deklariert sind, umso weniger Anpassungen sind notwendig. Im vorliegenden Beitrag schauen wir uns zunächst an, wie Sie die API-Deklarationen und die gegebenenfalls benötigten Konstanten und Typen überhaupt finden.<\/b><\/p>\n
Spätestens, wenn man Funktionen nutzen möchte, die nicht typischerweise von den eingebundenen Bibliotheken oder anderen, über den Verweise<\/b>-Dialog hinzugefügten Bibliotheken bereitgestellt werden, benötigt man API-Funktionen.<\/p>\n
Gängige Sätze solcher Funktionen dienen beispielsweise für folgende und viele weitere Anwendungszwecke:<\/p>\n
Für manche Szenarien fügt man dazu umfangreiche Module mit vielen Deklarationen von API-Funktionen zu einem VBA-Projekt hinzu. In vielen Fällen verwendet die Anwendung jedoch nur einen Bruchteil der in den Modulen enthaltenen Befehle – zum Beispiel bei Modulen mit Funktionen für den Umgang mit Bildern per GDI.<\/p>\n
Bevor man sich daran machen kann, die API-Funktionen in der mit 32-Bit-Access kompatiblen Fassung nach 64-Bit zu konvertieren, verschafft man sich erstmal einen Überblick über alle in einem Projekt enthaltenen APIs. Nun meinen wir damit nicht, dass Sie alle enthaltenen Module öffnen und diese manuell nach API-Deklarationen durchsuchen. Und wir wollen auch nicht die Suchfunktion nutzen, sondern uns selbst eine Routine schreiben, mit der wir alle Deklarationen von API-Funktionen finden.<\/p>\n
Dazu nutzen wir die Klassen, Eigenschaften und Methoden der Bibliothek Microsoft Visual Basic for Applications 5.3 Extensibility<\/b>, die wir über den Verweise<\/b>-Dialog (Menüpunkt Extras|Verweise <\/b>im VBA-Editor) zum Projekt hinzufügen (siehe Bild 1).<\/p>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2021_04\/pic_1312_001.png\")
<\/p>\n
Bild 1: Verweis auf die Bibliothek Microsoft Visual Basic for Applications 5.3 Extensibility<\/span><\/b><\/p>\n Als Erstes benötigen wir einen Verweis auf das aktuelle VBA-Projekt. Es kann nämlich sein, dass der VBA-Editor mehr als ein Projekt gleichzeitig im Projekt-Explorer anzeigt – zum Beispiel, wenn gerade ein Access-Add-In geöffnet ist oder wenn der Benutzer eine Bibliotheksdatenbank als Verweis eingebunden hat.<\/p>\n Um dieses VBA-Projekt zu ermitteln, verwenden wir die Hilfsfunktion GetCurrentVBProject<\/b>. Es durchläuft alle Elemente der VBProjects<\/b>-Auflistung des VBA-Editors, den wir mit der Klasse VBE <\/b>referenzieren, in einer For Each<\/b>-Schleife.<\/p>\n Dabei vergleicht die Funktion den Dateinamen des VBProject<\/b>-Objekts mit dem der aktuell geöffneten Access-Datenbank.<\/p>\n Stimmen diese überein, enthält objVBProject <\/b>einen Verweis auf das VBA-Projekt der aktuellen Datenbank-Datei und die Funktion liefert diesen als Funktionsergebnis zurück:<\/p>\n Dann beginnt der spannende Teil: die Suche nach den Deklarationen. Wie finden wir API-Deklarationen Müssen wir dazu jede einzelne Codezeile durchsuchen – und wonach genau suchen wir dabei<\/p>\n Der erste Hinweis ist: Jede Deklaration einer API-Funktion enthält das Schlüsselwort Declare<\/b>. Dieses finden wir in keiner anderen Prozedur oder Funktion.<\/p>\n Der zweite Hinweis lautet: Jedes Modul ist unterteilt in den oberen Bereich mit den Deklarationen und den unteren Bereich mit den Funktionen und Prozeduren. Vielleicht haben Sie schon einmal festgestellt, dass Sie die Deklaration einer Variable oder auch einer API-Funktion in einem VBA-Modul nicht unterhalb der ersten Routine platzieren können.<\/p>\n Probieren Sie dies dennoch, erhalten Sie beim Kompilieren des Projekts die Fehlermeldung aus Bild 2. Genau genommen ist der Text der Meldung nicht ganz korrekt, denn hinter End Sub <\/b>und so weiter können natürlich auch noch weitere Sub<\/b>-, Function<\/b>– oder Property<\/b>-Funktionen stehen.<\/p>\n Bild 2: Fehler beim Deklarieren einer Variablen hinter einer Routine<\/span><\/b><\/p>\n Das ist jedoch hier irrelevant – es geht nur darum, dass jegliche Deklaration von Variablen, Kontanten und API-Funktionen immer vor der ersten Sub<\/b>-, Function<\/b>– oder Property<\/b>-Prozedur stehen muss.<\/p>\n Wir müssen auf jeden Fall alle Module durchlaufen, um alle Deklarationen von API-Funktionen zu finden.<\/p>\n Das erledigen wir in einer einfachen For Each<\/b>-Schleife über alle Elemente des Typs VBComponent <\/b>der Auflistung VBComponents <\/b>des aktuellen VBProject<\/b>-Elements:<\/p>\n In diesem Fall geben wir die Namen aller Module im Direktbereich des VBA-Editors aus.<\/p>\n Das Durchsuchen der Codezeilen eines VBComponent<\/b>-Elements umfasst einige Anweisungen, daher erstellen wir dafür direkt eine eigene Routine, die wir innerhalb der Schleife aufrufen:<\/p>\n Die Prozedur FindAPIDeclaresInModule <\/b>nimmt den Verweis auf das VBComponent<\/b>-Objekt entgegen und weist das enthaltene CodeModule<\/b>-Objekt der Variablen objCodeModule <\/b>hinzu:<\/p>\n Für die danach folgende For…Next<\/b>-Schleife muss man wissen, dass das CodeModule<\/b>-Objekt eine eigene Eigenschaft bereitstellt, welche das Ende des Deklarationsbereichs des jeweiligen Moduls in Form der Zeilennummer liefert. Diese heißt CountOfDeclarationLines<\/b>.<\/p>\n Wir brauchen also nur alle Zeilen von der ersten bis zu der mit CountOfDeclarationLines <\/b>angegebenen Zeile zu durchlaufen, um alle möglichen Zeilen mit API-Deklarationen zu erwischen.<\/p>\n API-Deklarationen findet man oft in der mehrzeiligen Darstellung. Das ist übersichtlicher, wenn man beispielsweise jeden Parameter in einer neuen Zeile anzeigt:<\/p>\n Die Untersuchung wird dadurch jedoch erschwert. Um jegliche interessante Idee von Entwicklern auszuschließen, wollen wir vor der Untersuchung einer Zeile auf eine API-Funktion zunächst die mit dem Unterstrich-Zeichen gesplitteten Zeilen in einer Variablen zusammenführen. Das gelingt in der Prozedur wie in Listing 1.<\/p>\n Listing 1: Einlesen von mehrzeiligen Anweisungen als einzeilige Anweisungen<\/span><\/b><\/p>\n Hier durchlaufen wir nach wie vor alle Zeilen des Deklarationsbereichs, also bis zur Zeile aus CountOfDeclarationLines<\/b>. Dabei schreiben wir zuerst den Inhalte der aktuellen Zeile in die Variable strLine<\/b>.<\/p>\n In der folgenden Do While<\/b>-Schleife prüfen wir, ob die Anweisung der aktuellen Zeile mit einem Unterstrich endet, was bedeutet, dass diese in der folgenden Zeile fortgesetzt wird. In diesem Fall nehmen wir einige Änderungen vor:<\/p>\n Schließlich erhöhen wir innerhalb des Do While<\/b>-Schleifendurchlaufs den Wert der Zählervariablen lngZeile <\/b>um 1<\/b>, damit die gleiche Zeile nicht beim nächsten Durchlauf der For…Next<\/b>-Schleife erneut untersucht wird.<\/p>\n <\/p>\n Außerdem fügen wir den Inhalt der aktuellen Zeile an den Inhalt von strLine <\/b>an.<\/p>\n Danach prüfen wir noch, ob die Zeile noch weitere Hochkommata enthält, was auf angehängte Kommentare hinweist. Hier schneiden wir den Kommentar ab dem Hochkomma ab:<\/p>\n Als Ergebnis landen mehrzeilige Anweisungen als einzeilige Anweisung in der Variablen strLine<\/b>, wo wir diese dann weiter untersuchen können. In diesem Fall wollen wir wissen, ob die Zeile das Schlüsselwort Declare <\/b>enthält. Dieses Schlüsselwort kann sich allerdings an verschiedenen Positionen befinden. Die Erste ist der Anfang der Zeile:<\/p>\n Oder es folgt auf eines der Schlüsselwörter Private <\/b>oder Public<\/b>:<\/p>\n Es könnte sich auch in einem Routinen- oder Parameternamen verstecken:<\/p>\n Und zu guter Letzt kann eine Declare<\/b>-Zeile auch auskommentiert sein:<\/p>\n Wir machen also nichts verkehrt, wenn wir eine kleine Funktion programmieren, die prüft, ob es sich tatsächlich um eine Declare<\/b>-Zeile für eine API-Funktion handelt und die wir jeweils nach dem Einlesen einer vollständigen, gegebenenfalls auch aus mehreren Zeilen bestehenden Anweisung aufrufen. Hier zunächst der Aufruf der Funktion aus der Prozedur FindAPIDeclaresInModule <\/b>heraus:<\/p>\n Die Funktion IsDeclare <\/b>finden Sie in Listing 2. Die Funktion entfernt mit der Trim<\/b>-Funktion alle führenden und folgenden Leerzeichen der Zeile aus strLine<\/b>. Dann prüft sie, ob das erste Zeichen ein Kommentarzeichen ist (“<\/b>). Falls nicht, untersucht sie, ob die Zeile die Zeichenfolge Declare <\/b>direkt zu Beginn aufweist oder ob die Zeichenfolge Declare <\/b>mit führendem und folgendem Leerzeichen weiter hinten folgt.<\/p>\n Listing 2: Ermitteln, ob eine Zeile eine Declare-Anweisung enthält<\/span><\/b><\/p>\n Damit können wir innerhalb der If IsDeclare(strLine) Then<\/b>-Bedingung per Debug.Print<\/b> alle tatsächlichen API-Deklarationen ausgeben.<\/p>\n Damit ist die Arbeit allerdings noch nicht zu Ende. Wir wollen die API-Deklarationen zunächst in einer Tabelle namens tblAPIDeclarations<\/b> speichern (siehe Bild 3).<\/p>\n Bild 3: Entwurf der Tabelle zum Speichern der API-Deklarationen<\/span><\/b><\/p>\n Diese Tabelle soll die folgenden Felder enthalten:<\/p>\n Außerdem legen wir noch eine weitere Tabelle namens tblAPIParameters <\/b>an. Diese soll die einzelnen Parameter der Deklaration der API-Funktionen speichern:<\/p>\n Den Entwurf dieser Tabelle finden Sie in Bild 4.<\/p>\n Bild 4: Entwurf der Tabelle zum Speichern der API-Parameter<\/span><\/b><\/p>\n Die Beziehung zwischen den beiden Tabellen stellen wir über das Fremdschlüsselfeld APIDeclarationID <\/b>der Tabelle tblAPIParameters <\/b>und das gleichnamige Primärschlüsselfeld der Tabelle tblAPIDeclarations <\/b>her. Für die Beziehung mit referenzieller Integrität legen wir außerdem die Löschweitergabe fest, damit beim Löschen von Deklarationen auch gleich die Parameter gelöscht werden (siehe Bild 5).<\/p>\n Bild 5: Beziehung zwischen den beiden beteiligten Tabellen<\/span><\/b><\/p>\n Die Prozedur SaveAPIDeclarations <\/b>erledigt das Speichern der API-Deklaration in der Tabelle tblAPIDeclarations<\/b>. Sie wird von der Prozedur FindAPIDeclaresInModule <\/b>innerhalb der For…Next<\/b>-Schleife wie folgt aufgerufen:<\/p>\n Die Prozedur SaveAPIDeclarations <\/b>selbst finden Sie in Listing 3. Sie erwartet den Namen des Moduls, in dem sich die API-Deklaration befindet, sowie die Zeile mit der API-Deklaration als Parameter. Die Prozedur ermittelt als Erstes das erste Auftreten der Zeichenkette Sub <\/b>(mit führendem und folgendem Leerzeichen) und speichert es in der Variablen lngPosStart<\/b>.<\/p>\nAktuelles VBA-Projekt identifizieren<\/h2>\n
Public Function <\/span>GetCurrentVBProject() As <\/span>VBProject\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBComponent\r\n For Each objVBProject In VBE.VBProjects\r\n If <\/span>(objVBProject.FileName = CurrentDb.Name) Then<\/span>\r\n Set<\/span> GetCurrentVBProject = objVBProject\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> objVBProject\r\nEnd Function<\/span><\/pre>\nSuche nach den API-Deklarationen<\/h2>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2021_04\/pic_1312_002.png\")
<\/p>\nAlle Module durchlaufen<\/h2>\n
Public Sub <\/span>FindAPIDeclares()\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBComponent\r\n Set<\/span> objVBProject = GetCurrentVBProject\r\n For Each objVBComponent In objVBProject.VBComponents\r\n Debug.Print<\/span> objVBComponent.Name\r\n Next<\/span> objVBComponent\r\nEnd Sub<\/span><\/pre>\n...\r\nFor Each objVBComponent In objVBProject.VBComponents\r\n FindAPIDeclaresInModule objVBComponent\r\nNext<\/span> objVBComponent\r\n...<\/pre>\nAlle Deklarationszeilen untersuchen<\/h2>\n
Public Sub <\/span>FindAPIDeclaresInModule( objVBComponent As <\/span>VBComponent)\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Dim <\/span>lngLine As Long<\/span>\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n For lngLine = 1 To objCodeModule.CountOfDeclarationLines\r\n Debug.Print<\/span> objCodeModule.Lines(lngLine, 1)\r\n Next<\/span> lngLine\r\nEnd Sub<\/span><\/pre>\nAufgabe: Zeilenumbrüche<\/h2>\n
Declare Function GetDiskFreeSpace Lib \"kernel32\" Alias \"GetDiskFreeSpaceA\" ( _\r\n ByVal lpRootPathName As String<\/span>, _\r\n lpSectorsPerCluster As Long<\/span>, _\r\n lpBytesPerSector As Long<\/span>, _\r\n lpNumberOfFreeClusters As Long<\/span>, _\r\n lpTotalNumberOfClusters As Long<\/span>) _\r\nAs Long<\/pre>\n...\r\nFor lngLine = 1 To objCodeModule.CountOfDeclarationLines\r\n strLine = objCodeModule.Lines(lngLine, 1)\r\n Do While<\/span> Not<\/span> InStr<\/span>(1, objCodeModule.Lines(lngLine, 1), \" _\") = 0\r\n strLine = VBA.Replace<\/span>(strLine, \" _\", \" \")\r\n strLine = VBA.Replace<\/span>(strLine, \" \", \" \")\r\n strLine = VBA.Replace<\/span>(strLine, \" \", \" \")\r\n strLine = VBA.Replace<\/span>(strLine, \" \", \" \")\r\n strLine = VBA.Replace<\/span>(strLine, \"( \", \"(\")\r\n strLine = VBA.Replace<\/span>(strLine, \" )\", \")\")\r\n lngLine = lngLine + 1\r\n strLine = strLine & objCodeModule.Lines(lngLine, 1)\r\n Loop<\/span>\r\n If <\/span>Not<\/span> InStr<\/span>(1, strLine, \"''\") = 0 Then<\/span>\r\n strLine = Mid<\/span>(strLine, InStr<\/span>(1, strLine, \"''\"))\r\n End If<\/span>\r\n Debug.Print<\/span> strLine\r\nNext<\/span> lngLine\r\n...<\/pre>\n\n
If <\/span>Not<\/span> InStr<\/span>(1, strLine, \"''\") = 0 Then<\/span>\r\n strLine = Mid<\/span>(strLine, InStr<\/span>(1, strLine, \"''\"))\r\nEnd If<\/span><\/pre>\nDas Schlüsselwort Declare finden<\/h2>\n
Declare Function CloseClipboard Lib \"user32\" () As Long<\/span><\/pre>\nPrivate <\/span>Declare Function CloseClipboard Lib \"user32\" () As Long<\/span><\/pre>\nPublic Sub <\/span>FindDeclares()<\/pre>\n''Declare Function CloseClipboard Lib \"user32\" () As Long<\/span><\/pre>\nFor lngLine = 1 To objCodeModule.CountOfDeclarationLines\r\n ...\r\n If <\/span>Not<\/span> InStr<\/span>(1, strLine, \"Declare \") = 0 Then<\/span>\r\n If <\/span>IsDeclare(strLine) Then<\/span>\r\n Debug.Print<\/span> strLine\r\n End If<\/span>\r\n End If<\/span>\r\nNext<\/span> lngLine<\/pre>\nPublic Function <\/span>IsDeclare(strLine As String<\/span>) As Boolean<\/span>\r\n strLine = Trim<\/span>(strLine)\r\n If <\/span>Not<\/span> Left<\/span>(strLine, 1) = \"''\" Then<\/span>\r\n If <\/span>InStr<\/span>(1, strLine, \"Declare\") = 1 Or Not<\/span> InStr<\/span>(1, strLine, \" Declare \") = 0 Then<\/span>\r\n IsDeclare = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nAPI-Funktionsdeklarationen in Tabelle speichern<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2021_04\/pic_1312_003.png\")
<\/p>\n\n
\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2021_04\/pic_1312_004.png\")
<\/p>\n![\"Beziehung](\"..\/fileadmin\/_temp_\/2021_04\/pic_1312_005.png\")
<\/p>\nProzedur zum Speichern der API-Deklarationen<\/h2>\n
If <\/span>Not<\/span> InStr<\/span>(1, strLine, \"Declare \") = 0 Then<\/span>\r\n If <\/span>IsDeclare(strLine) Then<\/span>\r\n SaveAPIDeclaration objVBComponent.Name, strLine\r\n End If<\/span>\r\nEnd If<\/span><\/pre>\nPublic Sub <\/span>SaveAPIDeclaration(strModule As String<\/span>, strLine As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strAPICall As String<\/span>\r\n Dim <\/span>lngPosStart As Long<\/span>\r\n Dim <\/span>lngPosEnde As Long<\/span>\r\n Dim <\/span>strAPIReturnType As String<\/span>\r\n Dim <\/span>strAPIParameters As String<\/span>\r\n Dim <\/span>lngAPIDeclarationID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n lngPosStart = InStr<\/span>(1, strLine, \" Sub \")\r\n If <\/span>Not<\/span> lngPosStart = 0 Then<\/span>\r\n lngPosEnde = InStr<\/span>(lngPosStart + 5, strLine, \" \")\r\n strAPICall<\/span> = Mid<\/span>(strLine, lngPosStart + 5, lngPosEnde - lngPosStart - 5)\r\n Else<\/span>\r\n lngPosStart = InStr<\/span>(1, strLine, \" Function \")\r\n If <\/span>Not<\/span> lngPosStart = 0 Then<\/span>\r\n lngPosEnde = InStr<\/span>(lngPosStart + 10, strLine, \" \")\r\n strAPICall<\/span> = Mid<\/span>(strLine, lngPosStart + 10, lngPosEnde - lngPosStart - 10)\r\n End If<\/span>\r\n End If<\/span>\r\n lngPosStart = InStr<\/span>(1, strLine, \"(\")\r\n lngPosEnde = InStr<\/span>(1, strLine, \")\")\r\n strAPIParameters = Mid<\/span>(strLine, lngPosStart + 1, lngPosEnde - lngPosStart - 1)\r\n strAPIReturnType = Mid<\/span>(strLine, InStr<\/span>(1, strLine, \")\") + 1)\r\n strAPIReturnType = VBA.Replace<\/span>(strAPIReturnType, \"AS \", \"\")\r\n strAPIReturnType = Trim<\/span>(strAPIReturnType)\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblAPIDeclarations\", dbOpenDynaset)\r\n rst.Add