{"id":55000473,"date":"2025-06-01T00:00:00","date_gmt":"2025-08-27T13:52:44","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=473"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Ereignisse_aus_VBNETCOMDLLs_implementieren","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Ereignisse_aus_VBNETCOMDLLs_implementieren\/","title":{"rendered":"Ereignisse aus VB.NET-COM-DLLs implementieren"},"content":{"rendered":"

Viele Szenarien, in denen man eine COM-DLL benötigt, kann man mit einer VB6-COM-DLL auf Basis von twinBASIC abbilden. Manchmal möchte man aber auf Funktionen zugreifen, die einfacher mit einem VB.NET-Projekt zu erledigen sind. In diesem Artikel schauen wir uns nicht nur an, wie wir einen COM-DLL mit VB.NET erstellen, sondern legen den Fokus auf das Bereitstellen von Ereignissen und wie wir diese in dem VBA-Projekt, welches die COM-DLL nutzt, implementieren können.<\/b><\/p>\n

Beispielprojekt anlegen<\/h2>\n

Um das Beispielprojekt zu erstellen, benötigen wir Visual Studio, zum Beispiel in der Version 2022. Hier legen wir ein neues Projekt an und wählen dazu den Typ Klassenbibliothek (.NET-Framework) <\/b>aus (siehe Bild 1).<\/p>\n

\"Projekttyp<\/p>\n

Bild 1: Projekttyp für das neue Projekt auswählen<\/span><\/b><\/p>\n

Name festlegen<\/h2>\n

Anschließend erscheint der Dialog, mit dem wir den Namen des Projekts festlegen sowie das Verzeichnis, in dem es angelegt werden soll. Hier stellen wir für die Eigenschaft Name<\/b> den Wert amvEvents <\/b>ein (siehe Bild 2).<\/p>\n

\"Projekteigenschaften<\/p>\n

Bild 2: Projekteigenschaften vor dem Speichern festlegen<\/span><\/b><\/p>\n

Klasse umbenennen<\/h2>\n

Im nun erscheinenden Projekt-Explorer benennen wir als Erstes die Klasse Class1.vb<\/b> in Ereignis.vb <\/b>um. Visual Studio fragt uns nun, ob wir auch die Verweise auf das entsprechende Code-Element anpassen wollen, was wir bestätigen (siehe Bild 3).<\/p>\n

\"Umbenennen<\/p>\n

Bild 3: Umbenennen der Klasse des Projekts<\/span><\/b><\/p>\n

Assemblyinformationen anpassen<\/h2>\n

Damit kommen wir zu einigen Einstellungen, die für die Verwendung des Projekts als COM-DLL wichtig sind.<\/p>\n

Als Erstes klicken wir im Projektmappen-Explorer doppelt auf den Eintrag My Project<\/b>.<\/p>\n

Dies öffnet den Bereich mit den Eigenschaften des Projekts. Hier sehen wir unter Anwendung <\/b>die Schaltfläche Assemblyinformationen…<\/b> (siehe Bild 4).<\/p>\n

\"Bearbeiten<\/p>\n

Bild 4: Bearbeiten der Projekteigenschaften<\/span><\/b><\/p>\n

Diese klicken wir an und öffnen so den Dialog Assemblyinformationen<\/b>. Hier aktivieren wir im unteren Bereich die Option Assembly COM-sichtbar machen <\/b>(siehe Bild 5).<\/p>\n

\"Aktivieren<\/p>\n

Bild 5: Aktivieren der COM-Sichtbarkeit<\/span><\/b><\/p>\n

Nachdem wir den Dialog wieder geschlossen haben, wechseln wir in den Projekt-Optionen zum Bereich Kompilieren<\/b>. Hier finden wir ganz unten die Option Für COM-Interop registrieren<\/b>. Indem wir diese aktivieren, sorgen wir dafür, dass die COM-DLL beim Erstellen in die Registry eingetragen wird, sodass sie für den Zugriff von VBA aus verfügbar ist (siehe Bild 6).<\/p>\n

\"Aktivieren<\/p>\n

Bild 6: Aktivieren der Registrierung für COM-Interop<\/span><\/b><\/p>\n

Damit haben wir die Vorbereitungen abgeschlossen und können uns dem eigentlichen Programmieren zuwenden.<\/p>\n

Beispiel für ein COM-DLL-Ereignis programmieren<\/h2>\n

Das Ziel der folgenden Schritte ist die Programmierung des einfachsten denkbaren Beispiels für das Bereitstellen eines Ereignisses durch die COM-DLL. Dazu wollen wir die folgende Struktur realisieren:<\/p>\n

    \n
  • Programmierung eines Ereignisses mit dem Schlüsselwort Event<\/b>, so wie es auch in VBA realisierbar ist<\/li>\n
  • Hinzufügen einer öffentlichen Methode, mit der wir das Ereignis auslösen können.<\/li>\n<\/ul>\n

    Damit die Elemente der COM-DLL optimal im VBA-Editor genutzt werden können, können wir nicht einfach eine Klasse mit der Definition des Ereignisses und der auslösenden Methode programmieren.<\/p>\n

    Unter VBA könnten wir das etwa wie folgt in einem Klassenmodul programmieren:<\/p>\n

    Public <\/span>Event Ereignis()\r\nPublic Sub <\/span>EreignisAusloesen()\r\n     RaiseEvent Ereignis()\r\nEnd Sub<\/span><\/pre>\n
    In VB.NET reicht das aber nicht aus. Hier benötigen wir einige weitere Elemente, damit das Ereignis problemlos funktioniert und nicht mehr Elemente als nötig unter VBA angezeigt werden. Die Klasse wird in Listing 1 im Überblick dargestellt, in den folgenden Abschnitten erläutern wir die einzelnen Elemente.<\/p>\n
    Imports System.Runtime.InteropServices\r\n<InterfaceType(ComInterfaceType.InterfaceIsDual)>\r\nPublic <\/span>Interface IEreignis\r\n     Sub EreignisAusloesen()\r\nEnd Interface\r\n<InterfaceType(ComInterfaceType.InterfaceIsIDispatch)>\r\nPublic <\/span>Interface IEreignisEvents\r\n     Sub Ereignis()\r\nEnd Interface\r\n<ClassInterface(ClassInterfaceType.None)>\r\n<ComSourceInterfaces(GetType(IEreignisEvents))>\r\nPublic Class<\/span> Ereignis\r\n     Implements IEreignis\r\n     Public <\/span>Event Ereignis()\r\n     Public <\/span>Sub EreignisAusloesen() Implements IEreignis.EreignisAusloesen\r\n         RaiseEvent Ereignis()\r\n     End Sub\r\nEnd Class<\/span><\/pre>\n
    Listing 1: Die Klasse Ereignis im Überblick<\/span><\/b><\/p>\n
    Notwendiger Namespace: InteropServices<\/h2>\n
    Damit wir die gleich im Detail beschriebenen speziellen COM-Interfaces verwenden können, fügen wir dem Modul als erste Zeile den Import des Namensraums System.Runtime.InteropServices <\/b>hinzu:<\/p>\n
    Imports System.Runtime.InteropServices<\/pre>\n
    Trennung von COM-Methoden und COM-Ereignissen<\/h2>\n
    Wenn wir in anderen Artikeln einmal COM-DLLs auf Basis von VB.NET vorgestellt haben, wurde dort auch schon immer ein Interface verwendet, welches die Klasse dann implementiert hat. Das hat den Sinn, dass wirklich nur die in dem Interface definierten Elemente wie Eigenschaften oder Methoden nach außen sichtbar werden – zum Beispiel unter VBA.<\/p>\n
    Wenn wir kein Interface verwenden würden, sehen wir unter VBA unnötige Elemente wie Equals<\/b>, GetHashCode <\/b>oder GetType<\/b>. Diese benötigen wir aber nicht und sie machen die Auswahl der Elemente per IntelliSense auch noch unübersichtlicher. Das ist also der Grund, warum wir ein Interface wie das folgende definieren:<\/p>\n
    <InterfaceType(ComInterfaceType.InterfaceIsDual)>\r\nPublic <\/span>Interface IEreignis\r\n     Sub EreignisAusloesen()\r\nEnd Interface<\/pre>\n
    Hier legen wir zunächst den Typ des Interfaces fest, und zwar ComInterfaceType.InterfaceIsDual<\/b>. damit stellen wir sicher, dass alle in diesem Interface deklarierten Methoden, Eigenschaften und so weiter auch unter VBA angezeigt und verwendet werden können – sowohl per IntelliSense als auch im Objektkatalog.<\/p>\n
    Hier sehen wir allerdings nur die Methode EreignisAusloesen<\/b> und nicht die Definition des Ereignisses selbst. Dieses müssen wir in einem eigenen Interface definieren.<\/p>\n
    Für dieses verwenden wir wiederum einen anderen Interface-Typ, nämlich ComInterfaceType.InterfaceIsDispatch<\/b>. Nur so können wir Ereignisse empfangen. Das Ereignis definieren wir durch eine einfache Sub<\/b>-Definition wie folgt:<\/p>\n
    <InterfaceType(ComInterfaceType.InterfaceIsIDispatch)>\r\nPublic <\/span>Interface IEreignisEvents\r\n     Sub Ereignis()\r\nEnd Interface<\/pre>\n
    Logik der Klasse und Implementierung der Elemente<\/h2>\n
    Schließlich folgt die eigentliche Logik beziehungsweise die Implementierung der beiden Elemente, also der Methode und des Ereignisses.<\/p>\n
    Dies geschieht in der eigentlichen Klasse Ereignis<\/b>, die das Interface IEreignis <\/b>mit der Methode EreignisAusloesen <\/b>implementiert. Diese Klasse deklarieren wir als Klassen-Interface mit dem Typ ClassInterfaceType.None<\/b>. Die Elemente dieser Klasse werden dadurch nicht automatisch veröffentlicht und erscheinen somit nicht im VBA-Projekt, wenn wir diesem einen Verweis auf die COM-DLL hinzufügen. Das ist auch nicht nötig, denn alle Elemente haben wir bereits über die zuvor beschriebenen Elemente mit den Interface-Typen InterfaceIsDual <\/b>(für die Eigenschaften und Methoden) sowie InterfaceIsDispatch <\/b>(für die Ereignisse) veröffentlicht.<\/p>\n
    Wie aber machen wir in dieser Klasse kenntlich, durch welche öffentlichen Elemente die Methode und das Ereignis nach außen verfügbar gemacht werden?<\/p>\n
    Für das Interface IEreignis <\/b>gelingt dies durch zwei Maßnahmen:<\/p>\n
      \n
    • Wir fügen der Klasse Ereignis <\/b>über das Schlüsselwort Implements <\/b>das Interface IEreignis <\/b>hinzu.<\/li>\n
    • Dadurch müssen wir alle Elemente dieses Interfaces auch implementieren. Dass die Methode EreignisAusloesen <\/b>der Klasse Ereignis <\/b>die gleichnamige Methode EreignisAusloesen <\/b>der Schnittstelle IEreignis <\/b>implementiert, legen wir dabei durch den Zusatz Implements IEreignis.EreignisAusloesen <\/b>fest.<\/li>\n<\/ul>\n
      Für das Interface IEreignisEvents <\/b>müssen wir lediglich das Attribut  <\/b>über der Klasse angeben.<\/p>\n
      Wir können dann mit Public Event Ereignis() <\/b>das Ereignis definieren.<\/p>\n
      Die Klasse Ereignis <\/b>sieht nun wie folgt aus:<\/p>\n
      <ClassInterface(ClassInterfaceType.None)>\r\n<ComSourceInterfaces(GetType(IEreignisEvents))>\r\nPublic Class<\/span> Ereignis\r\n     Implements IEreignis\r\n     Public <\/span>Event Ereignis()\r\n     Public <\/span>Sub EreignisAusloesen() _\r\n             Implements IEreignis.EreignisAusloesen\r\n         RaiseEvent Ereignis()\r\n     End Sub\r\nEnd Class<\/span><\/pre>\n
      Zwischenstand<\/h2>\n
      Wir haben nun also drei Elemente:<\/p>\n
        \n
      • Ein Interface für die Eigenschaften und Methoden namens IEreignis<\/b>,<\/li>\n
      • ein Interface für die Ereignisse namens IEreignisEvents <\/b>und<\/li>\n
      • eine Klasse, welche die beiden Interfaces implementiert.<\/li>\n<\/ul>\n
        COM-DLL erstellen<\/h2>\n
        Damit können wir die COM-DLL nun erstellen. Das erledigen wir mit dem Befehl Erstellen|amvEvents <\/b>erstellen. Alternativ können wir dazu die Tastenkombination Strg + B <\/b>nutzen.<\/p>\n
        Voraussetzung für das Erstellen ist, dass Visual Studio im Administrator-Modus geöffnet wurde. Falls nicht, erscheint eine Fehlermeldung und wir müssen Visual Studio erneut starten – diesmal mit Administrator-Berechtigungen.<\/p>\n
        Wichtig ist außerdem, dass Du die COM-DLL mit der gleichen Bitness erzeugst, die auch Deine Office-Installation aufweist.<\/p>\n
        Wenn Du Office in der 32-Bit-Version nutzt, musst Du in den Projekteigenschaften unter Kompilieren die Eigenschaft Ziel-CPU auf x86<\/b> einstellen (siehe Bild 7).<\/p>\n
        \"Einstellen<\/p>\n
        Bild 7: Einstellen der Ziel-Bitness<\/span><\/b><\/p>\n
        Möchtest Du hingegen für Office in der 64-Bit-Version kompilieren, benötigst Du die Einstellung x64<\/b>.<\/p>\n
        Dass Du die falsche Bitness verwendet hast, erkennst Du daran, dass zwar die COM-DLL als Verweis eingebunden werden kann, dann aber bei der Benutzung Fehler wirft – zum Beispiel den aus Bild 8. Der Fehler ist nicht unbedingt selbsterklärend, deshalb weisen wir hier gezielt darauf hin.<\/p>\n
        \"Fehler<\/p>\n
        Bild 8: Fehler bei falscher Bitness<\/span><\/b><\/p>\n
        Das Erstellen legt die DLL an und fügt entsprechende Einträge zur Registry hinzu, damit zum Beispiel der VBA-Editor diese über den Verweise<\/b>-Dialog anzeigen kann.<\/p>\n
        COM-DLL in ein VBA-Projekt einbinden<\/h2>\n
        Damit können wir eine Access-Anwendung starten und den VBA-Editor anzeigen (zum Beispiel mit Alt + F11<\/b>).<\/p>\n
        Hier fügen wir einen Verweis auf die Bibliothek amvEvents <\/b>hinzu (siehe Bild 9).<\/p>\n
        \"Hinzufügen<\/p>\n
        Bild 9: Hinzufügen eines Verweises auf die COM-DLL<\/span><\/b><\/p>\n
        Schauen wir uns die Bibliothek amvEvents <\/b>im Objektkatalog an, finden wir die Klasse Ereignis <\/b>mit der Methode EreignisAusloesen <\/b>und dem Ereignis Ereignis<\/b> (siehe Bild 10).<\/p>\n
        \"Objektkatalog<\/p>\n
        Bild 10: Objektkatalog mit den Elementen der Ereignis-Klasse<\/span><\/b><\/p>\n
        Ereignis per Formular auslösen <\/h2>\n
        Nun legen wir ein Formular an und fügen diesem eine Schaltfläche namens cmdEreignisAusloesen <\/b>hinzu. (siehe Bild 11). Warum ein Formular und nicht einfach ein Standardmodul? Weil wir die Klasse Ereignis <\/b>mit dem Schlüsselwort WithEvents <\/b>deklarieren müssen, um das Ereignis implementieren zu können – und das gelingt nur in einem Klassenmodul. Hier liegt ein Formular-Klassenmodul für Beispielzwecke näher als die Erstellung eines alleinstehenden Klassenmoduls, das wir noch initialisieren müssten.<\/p>\n
        \"Formular<\/p>\n
        Bild 11: Formular zum Testen des Ereignisses<\/span><\/b><\/p>\n
        Im Klassenmodul des Formulars fügen wir nun zunächst eine Variable für die Klasse amvEvents.Ereignis <\/b>hinzu, die wir objEreignis <\/b>nennen und mit dem bereits erwähnten Schlüsselwort WithEvents <\/b>deklarieren:<\/p>\n
        Private <\/span>WithEvents objEreignis As <\/span>amvEvents.Ereignis<\/pre>\n
        Dann fügen wir für die Ereigniseigenschaft Beim Laden <\/b>die folgende Prozedur hinzu, die ein Objekt auf Basis von amvEvents.Ereignis <\/b>initialisiert:<\/p>\n
        Private Sub <\/span>Form_Load()\r\n     Set<\/span> objEreignis = New<\/span> amvEvents.Ereignis\r\nEnd Sub<\/span><\/pre>\n
        Außerdem müssen wir das Ereignis implementieren. Dazu wählen wir im linken Kombinationsfeld im Code-Fenster den Eintrag objEreignis<\/b>, wodurch im rechten Kombinationsfeld automatisch das Ereignis Ereignis <\/b>ausgewählt und die passende Ereignisprozedur angelegt wird (siehe Bild 12).<\/p>\n
        \"Implementieren<\/p>\n
        Bild 12: Implementieren des Ereignisses<\/span><\/b><\/p>\n
        Diese ergänzen wir durch eine einfache Meldungsbox:<\/p>\n
        Private Sub <\/span>objEreignis_Ereignis()\r\n     MsgBox<\/span> \"Ereignis ausgelöst\"\r\nEnd Sub<\/span><\/pre>\n
        Nun müssen wir nur noch dafür sorgen, dass das Ereignis ausgelöst wird.<\/p>\n
        Dazu fügen wir der Schaltfläche eine Ereignisprozedur hinzu, welche die Methode EreignisAusloesen <\/b>von objEreignis <\/b>aufruft:<\/p>\n
        Private Sub <\/span>cmdEreignisAusloesen_Click()\r\n     objEreignis.EreignisAusloesen\r\nEnd Sub<\/span><\/pre>\n
        Was geschieht nun? Die Methode EreignisAusloesen <\/b>ruft die entsprechende Sub<\/b>-Prozedur in der COM-DLL auf. Diese wiederum löst mit RaiseEvent Ereignis() <\/b>das Ereignis aus. Dadurch wird die in unserem Modul definierte Ereignisprozedur objEreignis_Ereignis <\/b>ausgelöst. Wir haben also ein funktionierendes in unserer COM-DLL programmiert.<\/p>\n
        Den Ablauf haben wir in Bild 13 übersichtlich skizziert. Das Click<\/b>-Ereignis der Schaltfläche wird an das Interface IEreignis <\/b>weitergeleitet, von wo aus es die Implementierung EreignisAusloesen <\/b>aufruft. Dies startet mit RaiseEvent <\/b>das Ereignis, was wiederum über das InterfaceIEreignisEvents <\/b>öffentlich bereitgestellt und von der Ereignisprozedur objEreignis_Ereignis <\/b>implementiert wird.<\/p>\n
        \"Ablauf<\/p>\n
        Bild 13: Ablauf des Codes<\/span><\/b><\/p>\n
        Einsatzmöglichkeiten<\/h2>\n
        Wir haben hier einen einfachen Einsatzzweck genutzt, der keinen echten Nutzen hat. Wir können das Beispiel jedoch beliebig erweitern, zum Beispiel, indem wir hinter die Prozedur EreignisAusloesen <\/b>eine echte, gegebenenfalls länger dauernde Routine integrieren – zum Beispiel, um Daten aus dem Internet herunterzuladen, Dateien zu generieren, einen Export oder Import zu beginnen oder einen Timer zu starten.<\/p>\n
        Mit dem Ereignis Ereignis <\/b>können wir dann an Access zurückmelden, wenn die gewünschten Aufgaben durch die COM-DLL durchgeführt wurden.<\/p>\n
        In Access können wir darauf reagieren, indem wir beispielsweise die Anzeige aktualisieren und das Ergebnis mitteilen. Oder wir führen daraufhin in Access weitere Aktionen aus, welche auf dem Ergebnis der COM-DLL basieren.<\/p>\n
        Erweiterung: Ereignis mit Parametern<\/h2>\n
        Wer schon einmal die Ereignisse von Access-Formularen programmiert hat, der weiß:<\/p>\n