{"id":55000496,"date":"2025-12-01T00:00:00","date_gmt":"2026-02-05T15:44:27","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=496"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBA_Bedingte_Kompilierung_nutzen","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/VBA_Bedingte_Kompilierung_nutzen\/","title":{"rendered":"VBA: Bedingte Kompilierung nutzen"},"content":{"rendered":"

\"\"In VBA-Projekten kann es vorkommen, dass Anweisungen nur in bestimmten Situationen kompiliert werden sollen. Das bekannteste Beispiel sind die Deklarationen von API-Funktionen, die je nach VBA-Version mal in der 32-Bit- und mal in der 64-Bit-Variante bereitgestellt werden sollen. Da die 64-Bit-Version bei Verwendung von 32-Bit-Access unter Umständen Datentypen mit sich bringt, die es in der 32-Bit-Version nicht gibt, würde dies beim Kompilieren zu Fehlern führen. Daher gibt es die sogenannte bedingte Kompilierung, bei der man mit speziellen If…Then-Bedingungen dafür sorgen kann, dass nur die für die aktuelle Version relevanten Codezeilen kompiliert werden können. In diesem Artikel zeigen wir, wie die bedingte Kompilierung funktioniert. Außerdem stellen wir ein weiteres Beispiel vor, in dem wir entweder die Early Binding- oder die Late Binding-Verwendung von Variablen nutzen wollen – abhängig von einer zur Laufzeit gesetzten Bedingung.<\/b><\/p>\n

Bedingte Kompilierung<\/h2>\n

Die bedingte Kompilierung arbeitet mit If…Then<\/b>-Bedingungen, die mit einem vorangestellten Raute-Zeichen angelegt werden:<\/p>\n

#If VBA7 Then\r\n''API-Deklarationen für VBA7\r\n#Else\r\n''API-Deklarationen für ältere VBA-Version\r\n#End If<\/pre>\n
Hier haben wir bereits die erste von einigen wenigen eingebauten Kompilierungskonstanten verwendet, nämlich VBA7<\/b>. Diese hat den Wert True<\/b>, wenn VBA in der Version 7 verwendet wird. Den Wert dieser Konstanten können wir nur in einer mit dem Raute-Zeichen beginnenden Zeile auslesen, sie kann nicht einfach mit Debug.Print ermittelt werden. Die folgende Anweisung liefert kein Ergebnis:<\/p>\n
Debug.Print<\/span> VBA7<\/pre>\n
Wir können aber eine Prozedur schreiben, in der wir per #If…#Then<\/b>-Bedingung prüfen, ob VBA7 <\/b>den Wert True <\/b>oder False <\/b>hat:<\/p>\n
Public Sub <\/span>IsVBA7()\r\n#If VBA7 Then\r\n     Debug.Print<\/span> \"VBA7\"\r\n#Else\r\n     Debug.Print<\/span> \"Älteres VBA\"\r\n#End If\r\nEnd Sub<\/span><\/pre>\n
Dies liefert für aktuelle Office-Versionen (ab Version 2010) den Wert VBA7<\/b>.<\/p>\n
32-Bit oder 64-Bit?<\/h2>\n
Auf die gleiche Weise können wir herausfinden, ob die aktuelle Office-Version in der 32-Bit- oder in der 64-Bit-Version vorliegt.<\/p>\n
Hier verwenden wir die Kompilierungskonstante Win64<\/b>:<\/p>\n
Public Sub <\/span>Is32Or64Bit()\r\n#If Win64 Then\r\n     Debug.Print<\/span> \"64-Bit\"\r\n#Else\r\n     Debug.Print<\/span> \"32-Bit\"\r\n#End If\r\nEnd Sub<\/span><\/pre>\n
Wir können auch explizit auf die 32-Bit-Version prüfen:<\/p>\n
#If Win32 Then\r\n     Debug.Print<\/span> \"32-Bit\"\r\n#Else\r\n     Debug.Print<\/span> \"64-Bit\"\r\n#End If<\/pre>\n
Bedingte Kompilierung mit benutzerdefinierten Konstanten<\/h2>\n
Wir können auch eigene Kompilierungskonstanten definieren und diese per #If…#Then<\/b>-Bedingung abfragen.<\/p>\n
Diese Konstanten müssen ohne Datentyp angegeben werden und werden ebenfalls mit führenden Raute-Zeichen definiert, zum Beispiel:<\/p>\n
#Const cEarlyBinding = -1<\/pre>\n
Die Konstanten dürfen außerdem nur Long<\/b>-Werte enthalten. <\/p>\n
Diese fragen wir dann wie folgt ab:<\/p>\n
Public Sub <\/span>EigeneKonstante()\r\n#If cEarlyBinding = -1 Then\r\n     Debug.Print<\/span> \"cEarlyBinding ist True\"\r\n#Else\r\n     Debug.Print<\/span> \"cEarlyBinding ist False\"\r\n#End If\r\nEnd Sub<\/span><\/pre>\n
Bedingte Kompilierung für Early Binding und Late Binding<\/h2>\n
Wenn wir auf dem Entwicklungsrechner mit Early Binding arbeiten wollen, um IntelliSense nutzen zu können, aber auf dem Produktivrechner sicherstellen wollen, dass das Projekt auch ohne Vorhandensein der jeweiligen Bibliothek zumindest ohne Kompilierfehler verwendet werden kann, können wir hier die Anweisungen zum Deklarieren und Initialisieren von Objektvariablen einfügen:<\/p>\n
Public Sub <\/span>EarlyBinding()\r\n#If cEarlyBinding = -1 Then\r\n     Dim <\/span>rst As <\/span>adodb.Recordset\r\n     Set<\/span> rst = New<\/span> adodb.Recordset\r\n#Else\r\n     Dim <\/span>rst As Object<\/span>\r\n     Set<\/span> rst = CreateObject(\"ADODB.Recordset\")\r\n#End If\r\nEnd Sub<\/span><\/pre>\n
Wenn wir #cEarlyBinding <\/b>auf -1 <\/b>einstellen, werden die Anweisungen im #If<\/b>-Teil der Bedingung kompiliert und ausgeführt, andernfalls die aus dem #Else<\/b>-Teil. Das können wir leicht prüfen, indem wir die Anweisungen schrittweise durchlaufen.<\/p>\n
Wenn wir die Konstante #cEarlyBinding <\/b>auf den Wert -1 <\/b>einstellen und die Bibliothek Microsoft ActiveX Data Objects x.y <\/b>nicht per Verweis eingebunden ist, erhalten wir außerdem einen Kompilierfehler (siehe Bild 1). Hier müssen wir also, solange wir auf dem Entwicklungsrechner arbeiten, den Wert von #cEarlyBinding <\/b>auf -1 <\/b>einstellen und den Wert vor der Weitergabe auf 0 <\/b>ändern.<\/p>\n
\"Kompilierfehler,<\/p>\n
Bild 1: Kompilierfehler, weil die ADODB-Bibliothek fehlt<\/span><\/b><\/p>\n
Kompilierungskonstanten in den Eigenschaften des VBA-Projekts speichern<\/h2>\n
Die Kompilierungskonstante cEarlyBinding <\/b>können wir auch in den Eigenschaften des VBA-Projekts hinterlegen. Diese öffnen wir über den Menübefehl Extras|Eigenschaften von [Projektname]… <\/b>und erhalten den Dialog aus Bild 2. Die Kompilierungskonstante aus dem Code können wir nun entfernen und die Kompilierung funktioniert dennoch wie erwartet.<\/p>\n
\"Kompilierungskonstanten<\/p>\n
Bild 2: Kompilierungskonstanten in den Eigenschaften des VBA-Projekts<\/span><\/b><\/p>\n
Kompilierkonstanten zur Laufzeit einstellen<\/h2>\n
Dies hat den Vorteil, dass wir die Kompilierungskonstante auch zur Laufzeit einstellen können, was bei der Konstanten im Code nicht möglich ist. Dazu nutzen wir die SetOption<\/b>-Methode des Application<\/b>-Objekts. Hier stellen wir die Konstante cEarlyBinding <\/b>auf den Wert -1 <\/b>ein:<\/p>\n
Public Sub <\/span>KompilierungskonstanteEinstellen()\r\n     Application.SetOption _\r\n         \"Conditional Compilation Arguments\", _\r\n         \"cEarlyBinding=-1\"\r\nEnd Sub<\/span><\/pre>\n
Diese Konstante können wir in Abhängigkeit von verschiedenen Bedingungen einstellen. Wir könnten zum Beispiel prüfen, ob sich die Datenbank auf dem Entwicklungsrechner an einem bestimmten Ort befindet, zum Beispiel so:<\/p>\n
Public Sub <\/span>KompilierungskonstanteEinstellen()\r\n     If CurrentDb.Name = _\r\n             \"C:\\...\\VBABedingteKompilierungNutzen.accdb\" Then\r\n         Application.SetOption _\r\n             \"Conditional Compilation Arguments\", _\r\n             \"cEarlyBinding=-1\"\r\n     Else<\/span>\r\n         Application.SetOption _\r\n             \"Conditional Compilation Arguments\", _\r\n             \"cEarlyBinding=0\"\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Dann wird auf dem Entwicklungsrechner die Konstante auf -1 <\/b>eingestellt und andernfalls auf 0 <\/b>(außer, beim Benutzer ist die Datenbank zufällig unter genau dem gleichen Pfad gespeichert).<\/p>\n
Damit die Konstante für die bedingte Kompilierung direkt beim Start der Anwendung festgelegt wird, können wir ein AutoExec-Makro definieren, das eine Funktion mit den obigen Anweisungen ausführt. Für das AutoExec<\/b>-Makro legen wir die AusführenCode<\/b>-Aktion fest und tragen als auszuführende Funktion den Wert =BedingteKompilierung() <\/b>ein (siehe Bild 3).<\/p>\n
\"AutoExec-Makro<\/p>\n
Bild 3: AutoExec-Makro zum Aufrufen der Funktion zum Einstellen der Konstanten für die bedingte Kompilierung<\/span><\/b><\/p>\n
Die folgende Funktion enthält die gleichen Anweisungen wie die zuvor beschriebene:<\/p>\n
Public Function <\/span>BedingteKompilierung()\r\n     ...\r\nEnd Function<\/span><\/pre>\n
Beim Start der Anwendung wird nun das AutoExec<\/b>-Makro aufgerufen, das wiederum die Funktion BedingteKompilierung <\/b>startet. Dadurch wird die Kompilierungskonstante cEarlyBinding <\/b>auf den entsprechenden Wert eingestellt.<\/p>\n
Mehrere Kompilierungskonstanten verwenden<\/h2>\n
Wir können auch mehrere Konstanten hinterlegen. Diese müssen wir durch einen Doppelpunkt voneinander trennen (siehe Bild 4).<\/p>\n
\"Beispiel<\/p>\n
Bild 4: Beispiel für mehrere Kompilierungskonstanten<\/span><\/b><\/p>\n
Dass dies funktioniert, prüfen wir mit der folgenden Funktion:<\/p>\n
Public Function <\/span>TestMehrereKonstanten()\r\n#If A = -1 Then\r\n     Debug.Print<\/span> \"A = -1\"\r\n#Else\r\n     Debug.Print<\/span> \"A = 0\"\r\n#End If\r\n#If B = -1 Then\r\n     Debug.Print<\/span> \"B = -1\"\r\n#Else\r\n     Debug.Print<\/span> \"B = 0\"\r\n#End If\r\nEnd Function<\/span><\/pre>\n
Vorsicht, .accde-Datenbanken!<\/h2>\n
Achtung: <\/b>Das Setzen der Kompilierkonstanten per VBA funktioniert nicht in .accde<\/b>-Datenbanken!<\/p>\n
Zusammenfassung und Ausblick<\/h2>\n
Dieser Artikel zeigt, wie man die bedingte Kompilierung nutzt, um bestimmte Anweisungen nur unter den entsprechenden Bedingungen zu kompilieren und ausführbar zu machen.<\/p>\n
Damit können wir beispielsweise API-Funktionen für 32-Bit und 64-Bit deklarieren oder Early Binding und Late Binding gezielt einsetzen.<\/p>\n
Downloads zu diesem Beitrag<\/h2>\n
Enthaltene Beispieldateien:<\/p>\n
VBABedingteKompilierungNutzen.accdb<\/p>\n
Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
In VBA-Projekten kann es vorkommen, dass Anweisungen nur in bestimmten Situationen kompiliert werden sollen. Das bekannteste Beispiel sind die Deklarationen von API-Funktionen, die je nach VBA-Version mal in der 32-Bit- und mal in der 64-Bit-Variante bereitgestellt werden sollen. Da die 64-Bit-Version bei Verwendung von 32-Bit-Access unter Umständen Datentypen mit sich bringt, die es in der 32-Bit-Version nicht gibt, würde dies beim Kompilieren zu Fehlern führen. Daher gibt es die sogenannte bedingte Kompilierung, bei der man mit speziellen If…Then-Bedingungen dafür sorgen kann, dass nur die für die aktuelle Version relevanten Codezeilen kompiliert werden können. In diesem Artikel zeigen wir, wie die bedingte Kompilierung funktioniert. Außerdem stellen wir ein weiteres Beispiel vor, in dem wir entweder die Early Binding- oder die Late Binding-Verwendung von Variablen nutzen wollen – abhängig von einer zur Laufzeit gesetzten Bedingung.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662025,66062025,44000026,44000025],"tags":[],"yst_prominent_words":[],"class_list":["post-55000496","post","type-post","status-publish","format-standard","hentry","category-662025","category-66062025","category-Outlook_programmieren","category-VBAProgrammierung"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t