{"id":55001530,"date":"2025-02-01T00:00:00","date_gmt":"2025-01-08T11:21:21","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1530"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Early_Binding_und_Late_Binding_gleichzeitig_nutzen","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Early_Binding_und_Late_Binding_gleichzeitig_nutzen\/","title":{"rendered":"Early Binding und Late Binding gleichzeitig nutzen"},"content":{"rendered":"

Early Binding und Late Binding sind zwei Konzepte für das gleiche Ziel: Die Eigenschaften und Methoden von Elementen einer Bibliothek unter VBA verfügbar zu machen. Beide unterscheiden sich in verschiedenen Punkten und haben Vor- und Nachteile. Diese ein wenig auszugleichen ist das Ziel dieses Beitrags: Wir wollen zeigen, wie man die Vorteile von Early Binding, wie z.B. den Einsatz von IntelliSense, nutzen und gleichzeitig schnell zu Late Binding übergehen kann, um die Vorteile von Late Binding zu nutzen. Dazu schauen wir uns zunächst noch einmal die wesentlichen Unterschiede an und kommen dann zu unserer Idee, beide Versionen parallel zu nutzen – mit einer Technik namens „bedingte Kompilierung“.<\/b><\/p>\n

Early Binding vs. Late Binding<\/h2>\n

Beide Methoden dienen dazu, die Klassen, Eigenschaften, Methoden und gegebenenfalls auch Ereignisse einer COM-Bibliothek in einem VBA-Projekt verfügbar zu machen. Solche COM-Bibliotheken können fertige Bibliotheken sein, aber wir können diese auch selbst erstellen – beispielsweise mit Visual Studio .NET oder twinBASIC.<\/p>\n

Beispiele für fertige Bibliotheken sind etwa die für den Zugriff auf die verschiedenen Office-Anwendungen. Wenn wir auf Outlook, Word oder Excel zugreifen wollen, um diese Anwendungen fernzusteuern oder auf die enthaltenen Daten zuzugreifen, benötigen wir die entsprechenden Klassen, die wiederum in Bibliotheken enthalten sind.<\/p>\n

Um auf diese Elemente zuzugreifen, referenzieren wir in der Regel eine Klasse mit einer Objektvariablen.<\/p>\n

Beim Early Binding fügen wir unserem VBA-Projekt einen festen Verweis auf die Bibliothek hinzu und können dann per VBA über IntelliSense auf die enthaltenen Klassen, Eigenschaften, Methoden und Ereignisse zugreifen.<\/p>\n

Beim Late Binding fügen wir keinen festen Verweis hinzu und können nicht über IntelliSense auf die Elemente zugreifen, da das VBA-Projekt die zu verwendenden Klassen nicht kennt.<\/p>\n

Early Binding verwenden<\/h2>\n

Wenn wir Early Binding nutzen wollen, benötigen wir als Erstes einen Verweis auf die jeweilige Bibliothek. Um diesen hinzuzufügen, wechseln wir von Access aus zum VBA-Editor (zum Beispiel mit der Tastenkombination Alt + F11<\/b>). Hier können wir nun beispielsweise die Objektbibliothek für den Zugriff auf Microsoft Outlook <\/b>über den Eintrag Microsoft Outlook 16.0 Object Library <\/b>hinzufügen (siehe Bild 1).<\/p>\n

\"Verweis<\/p>\n

Bild 1: Verweis auf Outlook hinzufügen<\/span><\/b><\/p>\n

Fügen wir nun ein neues, leeres VBA-Modul hinzu, können wir wie in Bild 2 eine Variable des Typs Outlook.Application <\/b>deklarieren, diese mit einer neuen Instanz von Outlook.Application <\/b>füllen und dann auf die Eigenschaften und Methoden dieser Klasse zugreifen.<\/p>\n

\"Outlook-Klassen<\/p>\n

Bild 2: Outlook-Klassen referenzieren und verwenden<\/span><\/b><\/p>\n

Late Binding verwenden<\/h2>\n

Wenn wir Late Binding nutzen, können wir für die Variable objOutlook <\/b>nicht explizit den Typ festlegen, sondern verwenden den Datentyp Object<\/b>.<\/p>\n

Außerdem können wir nicht das New<\/b>-Schlüsselwort verwenden, sondern müssen mit CreateObject <\/b>arbeiten. Die notwendigen Zeilen sehen wie folgt aus:<\/p>\n

Public Sub <\/span>OutlookReferenzierenLateBinding()\r\n     Dim <\/span>objOutlook As Object<\/span>\r\n     Set<\/span> objOutlook = CreateObject(\"Outlook.Application\")\r\n     Debug.Print<\/span> objOutlook.Name\r\nEnd Sub<\/span><\/pre>\n
Damit können wir beinahe alles erledigen, was wir auch mit Early Binding tun können. Die Unterschiede schauen wir uns nun im Detail an.<\/p>\n
Vor- und Nachteile von Early Binding<\/h2>\n
Beim Early Binding haben wir den Vorteil, dass wir IntelliSense nutzen können.<\/p>\n
Wenn wir kein IntelliSense nutzen können, müssen wir entweder alle relevanten Elemente, Eigenschaften und Methoden auswendig kennen oder die Dokumentation verwenden.<\/p>\n
Mit Early Binding bekommen wir alle Elemente zu sehen, wenn wir nach dem Variablennamen den Punkt eingeben.<\/p>\n
Ein weiterer Vorteil beim Early Binding ist die Performance. Dadurch, dass wir bereits definiert haben, mit welchen Objekttypen wir arbeiten, sparen wir Zeit bei der Ausführung.<\/p>\n
Der Code ist unter Umständen besser lesbar, weil wir in der Deklarationszeile angeben, welchen Typ die verschiedenen Objektvariablen aufweisen.<\/p>\n
Schließlich können wir für verschiedene Parameter mit vorgegebenen Werten aussagekräftige Konstanten statt der tatsächlichen Zahlenwerte verwenden. Ein Beispiel sehen Sie in Bild 3. Hier geben wir statt des Zahlenwertes 0 <\/b>für die zu erstellende E-Mail die Konstante olMailItem <\/b>an.<\/p>\n
\"Verwenden<\/p>\n
Bild 3: Verwenden von Konstanten<\/span><\/b><\/p>\n
Vor- und Nachteile von Late Binding<\/h2>\n
Bei Verwendung von Late Binding gestalten sich die Vor- und Nachteile wie folgt.<\/p>\n
Der wichtigste Vorteil beim Late Binding ist, dass wir keinen Verweis benötigen. Dadurch können auch keine Fehler beim Ausführen des Codes durch fehlerhafte Verweise auftreten.<\/p>\n
Ein fehlerhafter Verweis liegt vor, wenn wir beispielsweise die Bibliothek Microsoft Office 16.0 Object Library <\/b>in unserem VBA-Projekt hinzugefügt haben, aber die Anwendung auf einem Rechner ausführen, auf dem sich eine andere Version dieser Bibliothek befindet.<\/p>\n
Oder wir nutzen einen Verweis auf eine selbst erstellte DLL, die wir bei der Entwicklung verwenden, die aber auf dem System des Kunden nicht vorhanden ist. Dann treten schnell Fehler wegen des fehlerhaften Verweises auf – interessanterweise an Stellen, die wir gar nicht damit in Verbindung bringen, zum Beispiel beim Aufruf von einfachen VBA-Funktionen wie Left <\/b>oder Mid<\/b>.<\/p>\n
Da unter Verwendung von Late Binding kein solcher Verweis vorhanden ist, erhalten wir auch nicht automatisch die beschriebenen Fehlermeldungen. Und im Gegensatz zu Early Binding können wir bei Late Binding auch recht einfach prüfen, ob die jeweilige Bibliothek vorhanden ist, bevor es Fehlermeldungen hagelt. Dazu später mehr.<\/p>\n
Ein Nachteil von Late Binding ist, dass wir Objektvariablen nur mit dem Typ Object <\/b>und nicht mit dem spezifischen Typ deklarieren können. Somit können wir auch kein IntelliSense nutzen.<\/p>\n
Ein weiterer Nachteil ist, dass wir die von den Bibliotheken bereitgestellten Konstanten nicht nutzen können, sondern die dahinter stehenden Zahlenwerte verwenden müssen.<\/p>\n
Beide Methoden parallel verwenden<\/h2>\n
Wie kommen wir nun an das Beste aus beiden Welten?<\/p>\n
Genau genommen meinen wir damit, dass wir mit IntelliSense programmieren und das Projekt aber ohne feste Verweise weitergeben.<\/p>\n
Hierbei müssen wir natürlich abwägen, welche Bibliotheken wir dieser Spezialbehandlung unterziehen wollen.<\/p>\n
Solche Bibliotheken, die mit sehr hoher Wahrscheinlichkeit auf dem Rechner des Benutzers enthalten sind, können wir durchaus per Early Binding nutzen.<\/p>\n
Interessanter ist der Einsatz von Late Binding in solchen Fällen, in denen das Vorhandensein einer anderen Version als der bei der Entwicklung verwendeten Version wahrscheinlich ist oder in denen eine Bibliothek gar nicht verfügbar ist.<\/p>\n
Hier könnten wir zunächst mit Early Binding entwickeln und dann vor der Weitergabe der Anwendung auf Late Binding umstellen. Dazu sind die folgenden Schritte nötig:<\/p>\n