Sie haben ein altes VBA-Projekt geerbt, das Funktionen der Windows-API aufruft, und unter 64-Bit-Access meldet der Compiler Fehler in den Declare-Zeilen? Dann müssen die Deklarationen angepasst werden. Wie das Schritt für Schritt gelingt, welche Rolle die Compilerkonstanten VBA7 und Win64 dabei spielen und an welchen Stellen die Prüfung wirklich nötig ist, zeigt der vorliegende Beitrag.<\/b><\/p>\n
Was sich mit 64 Bit ändert<\/h2>\n
Lange Zeit war das ein Randthema, denn Office wurde standardmäßig in der 32-Bit-Version installiert. Ab Office 2019 und Microsoft 365 ist laut Microsoft die 64-Bit-Version die Vorgabe. Wer Anwendungen weitergibt, trifft deshalb immer häufiger auf 64-Bit-Access, und der Code muss damit zurechtkommen. Geändert werden muss er übrigens nur dort, wo er unter 64 Bit läuft. Wer weiterhin ausschließlich 32 Bit einsetzt, merkt nichts.<\/p>\n
Der Kern des Problems: Die Windows-API kennt Handles und Zeiger. Ein Fensterhandle, wie es FindWindow<\/b> liefert, ist im Kern eine Adresse, und die ist unter 64-Bit-Windows 64 Bit breit. Der VBA-Datentyp Long<\/b> hat dagegen immer 32 Bit. Weil VBA 6 keinen eigenen Datentyp für Zeiger kannte, nahm man dort einfach Long<\/b>. Passt ein 64-Bit-Wert nicht hinein, wird er abgeschnitten, und das kann bis zum Absturz der Anwendung führen.<\/p>\n
Microsoft hat dafür mit VBA 7 (Office 2010) drei Neuerungen eingeführt. Erstens muss jede Declare<\/b>-Anweisung in 64-Bit-Office das Schlüsselwort PtrSafe<\/b> enthalten. Zweitens gibt es den Datentyp LongPtr<\/b>. Er entspricht in 32-Bit-Office einem Long<\/b> und in 64-Bit-Office einem LongLong<\/b>, wächst also mit der Plattform.<\/p>\n
Drittens gibt es den Datentyp LongLong<\/b> selbst, eine vorzeichenbehaftete 64-Bit-Ganzzahl, die es nur in 64-Bit-Office gibt. Die Hintergründe zu den VBA-Versionen erläutert der Beitrag 32-Bit, 64-Bit, VBA-Version und Co. (www.access-im-unternehmen.de\/1322)<\/b>. Hier geht es um die praktische Umrüstung.<\/p>\nDie Compilerkonstanten im Überblick<\/h2>\n
Damit ein Projekt in mehreren Umgebungen kompiliert werden kann, gibt es vordefinierte Compilerkonstanten. Sie werden ausschließlich mit der Direktive #If … Then … #Else<\/b> verwendet und gelten im ganzen Projekt. Eigene Konstanten mit denselben Namen lassen sich nicht anlegen. Wichtig sind diese:<\/p>\n Die beiden Zeilen mit VBA6<\/b> und Win32<\/b> sind die eigentlichen Stolpersteine. Weil Win32<\/b> auch unter 64 Bit True<\/b> liefert, würde eine Abfrage auf Win32<\/b> vor der Abfrage auf Win64<\/b> den 64-Bit-Zweig nie erreichen.<\/p>\n Dasselbe gilt für VBA6<\/b> und VBA7<\/b>. Die richtige Reihenfolge lautet deshalb immer vom Neuen zum Alten. Die Funktion Plattform<\/b> im Modul mdlKonstanten<\/b> zeigt es:<\/p>\n Auf unserem Testrechner mit 32-Bit-Access liefert Debug.Print Plattform()<\/b> im Direktbereich den Wert 32 Bit<\/b>. Die Funktion KonstantenText<\/b> im selben Modul gibt alle fünf Konstanten aus:<\/p>\n Zwei Dinge fallen auf: VBA6<\/b> ist auch unter VBA 7 True<\/b>, und Win32<\/b> ist wahr, und das bliebe es auch unter 64 Bit. Wer die Konstanten also in der falschen Reihenfolge abfragt, landet im falschen Zweig, ohne dass der Compiler etwas bemängelt.<\/p>\n In der Beispieldatenbank ApiDeklarationenFuer64Bit.accdb<\/b> finden Sie vier Module. Das Modul mdlApiAlt<\/b> enthält vier typische Deklarationen im alten Stil, das Modul mdlApiNeu<\/b> dieselben Deklarationen in der angepassten Form. Dazu kommen mdlKonstanten<\/b> mit den Compilerkonstanten und mdlApiBeispiele<\/b> mit weiteren Beispielen. Die vier ersten Funktionen haben wir bewusst unterschiedlich gewählt: GetTickCount<\/b> liefert nur eine Zahl, FindWindow<\/b> gibt ein Handle zurück, GetWindowRect<\/b> erwartet ein Handle und eine Struktur, und FlashWindowEx<\/b> enthält ein Handle innerhalb einer Struktur.<\/p>\n So treffen wir die Fälle, die in der Praxis am häufigsten vorkommen. Die alten Deklarationen sehen so aus (siehe Listing 1).<\/p>\n Listing 1: Die vier Deklarationen im alten Stil<\/span><\/b><\/p>\n Der erste Schritt ist mechanisch: Vor Function<\/b> oder Sub<\/b> kommt in jeder Declare<\/b>-Zeile das Schlüsselwort PtrSafe<\/b>. Das reicht allein aber nicht, und hier liegt die eigentliche Gefahr. Microsoft zeigt es an der Funktion GetActiveWindow<\/b> (siehe Listing 2).<\/p>\n Listing 2: Drei Stufen derselben Deklaration (Beispiel aus der Microsoft-Dokumentation)<\/span><\/b><\/p>\n Die erste Zeile ist der alte Stand. Unter 64 Bit meldet der Compiler, dass das Schlüsselwort PtrSafe<\/b> fehlt. Die zweite Zeile kompiliert dort ohne Fehler, liefert aber einen abgeschnittenen Wert zurück, denn PtrSafe<\/b> sagt dem Compiler nur, dass Sie die Zeile für 64 Bit gedacht haben.<\/p>\n Erst die dritte Zeile ist richtig. Das ist die gefährlichste Stufe: Der Compiler schweigt, und der Fehler zeigt sich erst zur Laufzeit.<\/p>\n Jetzt fragen wir bei jedem Parameter und jedem Rückgabewert: Ist das eine Zahl oder ein Handle beziehungsweise ein Zeiger? Die Dokumentation der API-Funktion verrät es. Typen wie HWND<\/b>, HANDLE<\/b> oder LPVOID<\/b> werden zu LongPtr<\/b>. Typen wie DWORD<\/b> oder int<\/b> bleiben Long<\/b>.<\/p>\n Daraus folgt für unsere vier Funktionen: GetTickCount<\/b> bekommt nur PtrSafe<\/b>, denn die Rückgabe ist eine Zahl. Bei FindWindow<\/b> wird die Rückgabe zu LongPtr<\/b>, bei GetWindowRect<\/b> der Parameter hWnd<\/b>.<\/p>\n Der Rückgabewert von GetWindowRect<\/b> ist ein Wahrheitswert und bleibt Long<\/b>. Die neue Fassung zeigt Listing 3.<\/p>\n Listing 3: Die angepassten Deklarationen<\/span><\/b><\/p>\n Damit ist die Deklaration fertig, aber nicht der Aufruf. Die Variable, die das Handle aufnimmt, muss ebenfalls LongPtr<\/b> sein. Die Funktion FensterBreite<\/b> im Modul mdlApiNeu<\/b> ermittelt die Breite des Access-Fensters:<\/p>\n Der Klassenname OMain<\/b> steht für das Hauptfenster von Access. Wer die Variable hWnd<\/b> weiter als Long<\/b> deklariert, erhält in 32-Bit-Access kein Problem und merkt den Fehler erst, wenn die Anwendung auf 64 Bit läuft. Genau das ist der heimtückischste Stolperstein bei dieser Umstellung. Rufen wir die Funktion im Direktbereich auf, erhalten wir die Breite des Fensters in Pixeln: Debug.Print FensterBreite()<\/b>.<\/p>\n Schwieriger wird es bei Strukturen. Die Struktur RECT<\/b> besteht nur aus vier Long<\/b>-Werten und bleibt unverändert. Die Struktur FLASHWINFO<\/b> für FlashWindowEx<\/b> enthält dagegen ein Fensterhandle. Das Element hWnd<\/b> muss deshalb LongPtr<\/b> sein:<\/p>\n Das Element cbSize<\/b> verlangt die Größe der Struktur in Byte. Hier steckt eine Falle: Mit einem LongPtr<\/b> im Inneren kann sich die Größe der Struktur zwischen 32 und 64 Bit ändern. Eine feste Zahl wäre falsch.<\/p>\n Deshalb ermitteln wir die Größe mit Len<\/b> (udtFlash.cbSize = Len(udtFlash)<\/b>). In der Prozedur FensterBlinken<\/b> ist das bereits so umgesetzt. Dasselbe gilt für jede andere Struktur, die Handles oder Zeiger enthält.<\/p>\n Das Modul mdlApiBeispiele<\/b> enthält fünf weitere Deklarationen, an denen sich die Regeln gut erkennen lassen (siehe Listing 4).<\/p>\n Listing 4: Weitere angepasste Deklarationen<\/span><\/b><\/p>\n Bei Sleep<\/b> ist nichts zu tun außer PtrSafe<\/b>, denn die Wartezeit in Millisekunden ist eine Zahl. Auch bei GetUserName<\/b> bleibt alles Long<\/b>: Der Puffer ist ein String<\/b>, und nSize<\/b> wird als Referenz übergeben, was automatisch die Adresse der Variablen liefert. Das ist ein wichtiger Punkt. Nicht jeder Parameter, der in C ein Zeiger ist, wird in VBA zu LongPtr<\/b>.<\/p>\n Übergeben wir die Variable selbst, sorgt VBA für die Adresse. LongPtr<\/b> brauchen wir nur dort, wo wir den Zeigerwert selbst in einer Variablen halten oder übergeben:<\/p>\n Auf unserem Testrechner liefert Debug.Print BenutzerName()<\/b> den Windows-Benutzernamen.<\/p>\n Anders bei GetModuleHandle<\/b>. Die Funktion liefert ein Handle, also steht in Deklaration und Variable LongPtr<\/b>:<\/p>\n Ein Sonderfall ist CopyMemory<\/b>, die Deklaration für RtlMoveMemory<\/b>. Ziel und Quelle sind mit As Any<\/b> deklariert, hier übergeben wir einfach die Variablen. Die Länge ist dagegen eine Größenangabe in der Breite eines Zeigers und deshalb ein LongPtr<\/b>. Unter 32 Bit ändert das nichts, unter 64 Bit ist es notwendig:<\/p>\n Der Aufruf Debug.Print KopieTest()<\/b> liefert 4711<\/b>.<\/p>\n Besonders aufmerksam müssen wir bei Rückruffunktionen sein. EnumWindows<\/b> ruft für jedes Fenster eine Funktion auf, deren Adresse wir mit AddressOf<\/b> übergeben. Die Adresse ist ein Zeiger, also LongPtr<\/b> (Parameter lpEnumFunc<\/b>). Ebenso trägt die Rückruffunktion selbst Handles und Zeiger. Die Funktion EnumFensterProc<\/b> zählt die sichtbaren Fenster:<\/p>\n Aufgerufen wird sie über die Funktion SichtbareFenster<\/b>, die mit EnumWindows AddressOf EnumFensterProc, 0<\/b> die Zählung startet.<\/p>\n Die Rückruffunktion muss in einem Standardmodul stehen, und die Parameter müssen exakt zur Windows-Vorgabe passen: hWnd<\/b> und lParam<\/b> als LongPtr<\/b>, der Rückgabewert als Long<\/b>. Das Ergebnis von Debug.Print SichtbareFenster()<\/b> hängt davon ab, wie viele Fenster gerade geöffnet sind.<\/p>\n Nicht jede Zahl in einer API-Deklaration muss angefasst werden. Wir müssen nur dort prüfen, wo ein Wert die Breite eines Zeigers hat. Als Faustregel hilft diese Zuordnung anhand des Windows-Typs aus der Dokumentation der Funktion:<\/p>\n Daraus ergeben sich drei Regeln, an denen die meisten Fehler hängen. Erstens: LongPtr<\/b> und LongLong<\/b> sind nicht dasselbe. LongPtr<\/b> läuft auf beiden Plattformen, LongLong<\/b> nur unter 64 Bit. Wer LongLong<\/b> für ein Handle verwendet, bricht den Code unter 32 Bit. Zweitens: Ein LongLong<\/b> lässt sich nicht implizit einem kleineren Typ zuweisen. Das schützt vor versehentlichem Abschneiden. Wer es bewusst will, wandelt mit CLng<\/b> um.<\/p>\n Für die umgekehrte Richtung gibt es CLngLng<\/b> und, plattformunabhängig, CLngPtr<\/b>. Drittens: Ein Literal, das größer ist als der größte Long<\/b>-Wert, wird sonst zu Double<\/b>. Soll es ein LongLong<\/b> sein, hängen Sie das Typzeichen ^<\/b> an.<\/p>\n Ebenfalls zu prüfen sind Variablen, die Adressen aufnehmen. Die Funktionen VarPtr<\/b>, StrPtr<\/b> und ObjPtr<\/b> liefern laut Microsoft unter 64 Bit einen LongPtr<\/b>, unter 32 Bit einen Long<\/b>. Wer das Ergebnis in einer Long<\/b>-Variablen ablegt, schneidet die Adresse unter 64 Bit ab.<\/p>\n Die Größe einer LongPtr<\/b>-Variablen liefert die Funktion ZeigerLaenge<\/b> im Modul mdlKonstanten<\/b> mit LenB<\/b>. Bei uns sind es 4<\/b> Byte, unter 64 Bit sind es laut Microsoft acht.<\/p>\n Wer nur Access 2010 oder neuer unterstützt, braucht die Compilerkonstanten für die Deklarationen nicht. PtrSafe<\/b> und LongPtr<\/b> laufen in VBA 7 sowohl unter 32 als auch unter 64 Bit. Das ist der Normalfall, und die Listings in diesem Beitrag kommen deshalb ohne #If<\/b> aus.<\/p>\n Anders ist es, wenn ein Projekt auch noch unter Access 2007 oder älter laufen soll, denn dort kennt der Compiler PtrSafe<\/b> nicht. Dann benötigen Sie für jede Declare<\/b>-Anweisung beide Varianten, und zwar in dieser Form:<\/p>\n Auch die Variablen müssen dann mitspielen, denn LongPtr<\/b> kennt VBA 6 auch nicht. Hier ist der Aufwand deutlich höher, und die Frage, ob sich die Bereitstellung für Access 2007 überhaupt noch lohnt, sollten Sie vorher klären.<\/p>\n Die Konstante Win64<\/b> brauchen Sie dagegen nur, wenn der Code selbst unterschiedlich laufen muss, etwa weil Sie eine echte 64-Bit-Ganzzahl benötigen.<\/p>\n Dort verwenden wir sie, um den passenden Datentyp zu wählen. Die Funktion GrosseZahlLaenge<\/b> im Modul mdlKonstanten<\/b> verwendet im Kern dieses Muster:<\/p>\n Unter 32 Bit wird nur der Else<\/b>-Zweig kompiliert, der LongLong<\/b>-Zweig bleibt unberücksichtigt und führt nicht zu einem Fehler.<\/p>\n Die Funktion liefert hier mit LenB<\/b> den Wert 4<\/b>. Das ist der Grund, warum sich LongLong<\/b> nur innerhalb von #If Win64<\/b> sicher verwenden lässt.<\/p>\n Zum Test enthält jedes der beiden Module mdlApiAlt<\/b> und mdlApiNeu<\/b> eine Funktion, die alle vier API-Aufrufe ausführt und das Ergebnis als Text zurückgibt: ApiAltTest<\/b> und ApiNeuTest<\/b>.<\/p>\n Sie vergleichen unter anderem das per FindWindow<\/b> gefundene Handle mit Application.hWndAccessApp<\/b>. Stimmen beide überein, liefert der Test an der Stelle Hwnd=Wahr<\/b>. Wichtig: In 32-Bit-Access laufen alte und neue Fassung fehlerfrei, weil LongPtr<\/b> dort ein Long<\/b> ist. Der Unterschied zeigt sich erst unter 64 Bit, und dort kompiliert die alte Fassung gar nicht erst. Testen Sie Ihre umgerüsteten Projekte deshalb unbedingt auch in einer 64-Bit-Installation und rufen Sie jede API-Funktion mindestens einmal auf.<\/p>\n Hier noch einmal die wichtigsten Punkte:<\/p>\n\n
Public Function <\/span>Plattform() As String<\/span>\r\n #If Win64 Then\r\n Plattform = \"64 Bit\"\r\n #ElseIf Win32 Then\r\n Plattform = \"32 Bit\"\r\n #Else\r\n Plattform = \"16 Bit\"\r\n #End If\r\nEnd Function<\/span><\/pre>\nVBA6=True; VBA7=True; Win32=True; Win64=False; Mac=False<\/span><\/pre>\nDie Beispieldatenbank<\/h2>\n
Private <\/span>Declare Function GetTickCount Lib \"kernel32\" () As Long<\/span>\r\nPrivate <\/span>Declare Function FindWindow Lib \"user32\" Alias \"FindWindowA\" (ByVal lpClassName As String<\/span>, _\r\n ByVal lpWindowName As String<\/span>) As Long<\/span>\r\nPrivate <\/span>Declare Function GetWindowRect Lib \"user32\" (ByVal hWnd As Long<\/span>, lpRect As <\/span>RECT) As Long<\/span>\r\nPrivate <\/span>Declare Function FlashWindowEx Lib \"user32\" (pfwi As <\/span>FLASHWINFO) As Long<\/span><\/pre>\nSchritt 1: PtrSafe ergänzen<\/h2>\n
Declare Function GetActiveWindow Lib \"user32\" () As Long<\/span>\r\nDeclare PtrSafe Function GetActiveWindow Lib \"user32\" () As Long<\/span>\r\nDeclare PtrSafe Function GetActiveWindow Lib \"user32\" () As Long<\/span>Ptr<\/pre>\nSchritt 2: Handles und Zeiger als LongPtr<\/h2>\n
Private <\/span>Declare PtrSafe Function GetTickCount Lib \"kernel32\" () As Long<\/span>\r\nPrivate <\/span>Declare PtrSafe Function FindWindow Lib \"user32\" Alias \"FindWindowA\" (ByVal lpClassName As String<\/span>, _\r\n ByVal lpWindowName As String<\/span>) As Long<\/span>Ptr\r\nPrivate <\/span>Declare PtrSafe Function GetWindowRect Lib \"user32\" (ByVal hWnd As Long<\/span>Ptr, lpRect As <\/span>RECT) As Long<\/span>\r\nPrivate <\/span>Declare PtrSafe Function FlashWindowEx Lib \"user32\" (pfwi As <\/span>FLASHWINFO) As Long<\/span><\/pre>\nPublic Function <\/span>FensterBreite() As Long<\/span>\r\n Dim <\/span>hWnd As Long<\/span>Ptr\r\n Dim <\/span>udtRect As <\/span>RECT\r\n hWnd = FindWindow(\"OMain\", vbNullString)\r\n GetWindowRect hWnd, udtRect\r\n FensterBreite = udtRect.Right<\/span> - udtRect.Left\r\nEnd Function<\/span><\/pre>\nStrukturen mit Handles<\/h2>\n
Private <\/span>Type FLASHWINFO\r\n cbSize As Long<\/span>\r\n hWnd As Long<\/span>Ptr\r\n dwFlags As Long<\/span>\r\n uCount As Long<\/span>\r\n dwTimeout As Long<\/span>\r\nEnd Type<\/pre>\nWeitere Beispiele aus der Praxis<\/h2>\n
Private <\/span>Declare PtrSafe Sub Sleep Lib \"kernel32\" (ByVal dwMilliseconds As Long<\/span>)\r\nPrivate <\/span>Declare PtrSafe Function GetUserName Lib \"advapi32.dll\" _\r\n Alias \"GetUserNameA\" (ByVal lpBuffer As String<\/span>, nSize As Long<\/span>) As Long<\/span>\r\nPrivate <\/span>Declare PtrSafe Function GetModuleHandle Lib \"kernel32\" _\r\n Alias \"GetModuleHandleA\" (ByVal lpModuleName As String<\/span>) As Long<\/span>Ptr\r\nPrivate <\/span>Declare PtrSafe Sub CopyMemory Lib \"kernel32\" Alias \"RtlMoveMemory\" (Destination As <\/span>Any, Source As <\/span>Any, _\r\n ByVal Length As Long<\/span>Ptr)\r\nPrivate <\/span>Declare PtrSafe Function EnumWindows Lib \"user32\" _\r\n (ByVal lpEnumFunc As Long<\/span>Ptr, ByVal lParam As Long<\/span>Ptr) As Long<\/span>\r\nPrivate <\/span>Declare PtrSafe Function IsWindowVisible Lib \"user32\" (ByVal hWnd As Long<\/span>Ptr) As Long<\/span><\/pre>\nPublic Function <\/span>BenutzerName() As String<\/span>\r\n Dim <\/span>strPuffer As String<\/span>\r\n Dim <\/span>lngLaenge As Long<\/span>\r\n strPuffer = String(255, vbNullChar)\r\n lngLaenge = Len<\/span>(strPuffer)\r\n If <\/span>GetUserName(strPuffer, lngLaenge) <> 0 Then<\/span>\r\n BenutzerName = Left<\/span>(strPuffer, lngLaenge - 1)\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>ModulHandleVorhanden() As Boolean<\/span>\r\n Dim <\/span>hModul As Long<\/span>Ptr\r\n hModul = GetModuleHandle(\"kernel32\")\r\n ModulHandleVorhanden = (hModul <> 0)\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>KopieTest() As Long<\/span>\r\n Dim <\/span>lngQuelle As Long<\/span>\r\n Dim <\/span>lngZiel As Long<\/span>\r\n lngQuelle = 4711\r\n CopyMemory lngZiel, lngQuelle, LenB(lngQuelle)\r\n KopieTest = lngZiel\r\nEnd Function<\/span><\/pre>\nCallbacks mit AddressOf<\/h2>\n
Private Function <\/span>EnumFensterProc(ByVal hWnd As Long<\/span>Ptr, _\r\n ByVal lParam As Long<\/span>Ptr) As Long<\/span>\r\n If <\/span>IsWindowVisible(hWnd) <> 0 Then<\/span>\r\n mlngAnzahl = mlngAnzahl + 1\r\n End If<\/span>\r\n EnumFensterProc = 1\r\nEnd Function<\/span><\/pre>\nWo wirklich geprüft werden muss<\/h2>\n
\n
Wann Sie VBA7 und Win64 wirklich brauchen<\/h2>\n
#If VBA7 Then\r\n Private <\/span>Declare PtrSafe Function GetTickCount _\r\n Lib \"kernel32\" () As Long<\/span>\r\n#Else\r\n Private <\/span>Declare Function GetTickCount _\r\n Lib \"kernel32\" () As Long<\/span>\r\n#End If<\/pre>\n#If Win64 Then\r\n Dim <\/span>lngGross As Long<\/span>Long\r\n#Else\r\n Dim <\/span>lngGross As Long<\/span>\r\n#End If<\/pre>\nDie Funktionsfähigkeit prüfen<\/h2>\n
Checkliste für die Umrüstung<\/h2>\n
\n