<\/p>\n
Visual Studio bietet viel mehr Bibliotheken und Möglichkeiten als Access. Dafür ist es auch viel komplizierter. Zum Glück können wir beide Welten kombinieren, zum Beispiel durch Erstellen einer DLL mit Visual Studio, die Funktionen bereitstellt, die nur unter .NET zur Verfügung stehen, die Sie dann von Access aus per VBA referenzieren und nutzen können. Dieser Beitrag zeigt anhand eines Beispiels, wie das gelingt.<\/b><\/p>\n
Ohne Probleme möglich wird dies dadurch, dass Sie sich die Community Edition von Visual Studio, beispielsweise in der Version 2017, kostenlos herunterladen und diese nutzen können. Den Download finden Sie, wenn Sie bei Google nach Visual Studio 2017 Community <\/b>suchen.<\/p>\n
Nach dem Installieren und Starten von Visual Studio öffnen Sie über den Menüeintrag Datei|Neu|Projekt… <\/b>den Dialog zum Erstellen eines neuen Projekts. Hier wählen Sie links den Eintrag Installiert|Visual Basic|Windows Desktop <\/b>aus und in der Mitte dann Klassenbibliothek (.NET Framework)<\/b> – siehe Bild 1. Geben Sie den Namen des Projekts ein, hier CMD, und wählen Sie den Ordner aus, in dem das Projektverzeichnis erstellt werden soll.<\/p>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_001.png\")
<\/p>\n
Bild 1: Erstellen einer Klassenbibliothek<\/span><\/b><\/p>\n Ein Hinweis vorab: Wenn Sie die DLL erstellen möchten, müssen Sie Visual Studio als Administrator öffnen. Dazu geben Sie beispielsweise Visual Studio im Suchfeld von Windows ein, warten, bis der Eintrag Visual Studio 2017 auftaucht, klicken dann mit der rechten Maustaste auf diesen Eintrag und wählen aus dem nun erscheinenden Kontextmenü den Befehl Als Administrator ausführen <\/b>aus. Mit einer so gestarteten Instanz von Visual Studio können Sie nun auch DLLs auf dem aktuellen Rechner erstellen und registrieren.<\/p>\n Visual Studio empfängt Sie nun mit der im Codefenster geöffneten Klasse Class1<\/b>. Sie können hier nun erste Methoden eintragen.<\/p>\n Unser Ziel ist es, eine DLL zu erstellen, die Methoden einer Bibliothek, die nur unter .NET, nicht aber unter VBA zur Verfügung steht. Zu Testzwecken wollen wir zuerst einmal nur eine einfache Funktion über die DLL in VBA bereitstellen, welche nach dem Aufruf eine einfache Meldung anzeigt.<\/p>\n Wir ändern nun erst einmal den Namen der zu verwendenden Klasse, indem wir Class1.vb<\/b> im Projektmappen-Explorer in CMD.vb <\/b>umbenennen. Dazu klicken Sie diesen Eintrag im Projektmappen-Explorer mit der rechten Maustaste an und wählen dann den Befehl Umbenennen… <\/b>aus dem Kontextmenü aus. Geben Sie den neuen Namen ein und bestätigen Sie auch die nun erscheinende Meldung, wodurch Sie alle Verweise auf den vorherigen Namen auf den neuen Namen ändern (siehe Bild 2). In diesem Fall wird auch beispielsweise der Name der Klasse im Klassenmodul angepasst:<\/p>\n Bild 2: Umbenennen aller Verweise entsprechen des neuen Elementnamens<\/span><\/b><\/p>\n Um eine einfache Meldung auszugeben, nachdem die entsprechende Methode der Klasse aufgerufen wurde, legen Sie zunächst die gewünschte Sub<\/b>-Methode an:<\/p>\n Nun heißt der Befehl zum Ausgeben eines Meldungsfensters unter VB.NET etwas anders als unter VBA, also nicht MsgBox<\/b>. Stattdessen verwendet man unter VB.NET die Methode Show <\/b>der Klasse MessageBox<\/b>. Diese wiederum ist in DLL-Klassen nicht standardmäßig als Verweis eingebunden, was wir allerdings schnell nachholen können.<\/p>\n Dazu rufen Sie mit dem Menübefehl Projekt|Verweis hinzufügen… <\/b>den Dialog Verweis-Manager <\/b>auf. Hier klicken Sie links auf Assemblys<\/b>. Rechts oben im Suchfenster können Sie etwa System.Windows <\/b>eintippen. Die Einträge werden nach jedem Zeichen aktualisiert, sodass Sie schon bald den Eintrag System.Windows.Forms <\/b>in der Liste entdecken. Diesen markieren Sie durch einen Haken und schließen den Dialog mit einem Klick auf die Schaltfläche OK<\/b> (siehe Bild 3).<\/p>\n Bild 3: Hinzufügen eines Verweises für die MessageBox-Klasse<\/span><\/b><\/p>\n Diese Bibliothek machen wir nun in unserer Klasse verfügbar, indem wir diese mit der Imports<\/b>-Anweisung ganz oben einfügen:<\/p>\n Die Methode MeldungAusgeben <\/b>erweitern wir nun um den Aufruf der Show<\/b>-Methode der MessageBox<\/b>-Klasse:<\/p>\n <\/p>\n Außerdem benötigen wir noch eine spezielle Auszeichnung der Klasse CMD<\/b>, damit diese später unter VBA auch verfügbar ist. Dazu fügen Sie einen weiteren Namespace hinzu:<\/p>\n Außerdem statten Sie die Klasse mit einer Zusatzinformation aus, welche diese sichtbar macht:<\/p>\n Nun fehlen noch zwei Einstellungen, bevor wir die DLL erstmalig testen können. Um diese vorzunehmen, klicken Sie doppelt auf den Eintrag MyProject <\/b>im Projektmappen-Explorer. Im Bereich Anwendung <\/b>des nun erscheinenden Fensters klicken Sie nun auf Assemblyinformationen…<\/b>. Im nun erscheinenden Dialog Assemblyinformationen <\/b>finden Sie unten die Option Assembly COM-sichtbar machen<\/b>, die Sie nun aktivieren. Anschließend können Sie den Dialog wieder schließen (siehe Bild 4).<\/p>\n Bild 4: Einstellen der Eigenschaft Assembly COM-sichtbar machen<\/span><\/b><\/p>\n Danach bleiben Sie direkt bei den Projekteigenschaften und aktivieren Sie den Bereich Kompilieren<\/b>. Hier finden Sie ganz unten den Eintrag Für COM-Interop registrieren<\/b>, den Sie ebenfalls aktivieren. MIt dieser Einstellung sorgen Sie dafür, dass die DLL beim Erstellen sowohl im System registriert wird, als auch dass eine .tlb<\/b>-Datei erstellt wird, die Sie für die Registrierung auf anderen Systemen nutzen können (siehe Bild 5).<\/p>\n Bild 5: Registrieren für COM-Interop<\/span><\/b><\/p>\n Im Anschluss an diesen Schritt wollen wir die DLL zum ersten Mal zum Debuggen starten. Dazu rufen wir den Menübefehl Debugging|Debugging starten <\/b>auf. Das liefert allerdings nicht das erwartete Ergebnis, denn es erscheint die Fehlermeldung aus Bild 6. Das ist logisch: Eine DLL kann schließlich nicht gestartet werden, sondern stellt nur seine Befehle zur Verfügung.<\/p>\n Bild 6: Fehler beim Debuggen<\/span><\/b><\/p>\n Also erstellen wir die DLL zunächst, indem wir den Befehl Erstellen|Projektmappe erstellen <\/b>aufrufen. Dies verläuft ohne Fehlermeldungen, sodass wir uns ansehen, was sich nun getan hat. Als Erstes werfen wir dazu einen Blick in das Verzeichnis bin\/Debug <\/b>des Projektordners (siehe Bild 7). Hier finden wir die DLL und die .tlb<\/b>-Datei vor, die wichtig für uns sind.<\/p>\n Bild 7: Beim Erstellen angelegte Dateien<\/span><\/b><\/p>\n Dann öffnen wir einmal eine neue Access-Datenbank und zeigen den VBA-Editor an (Strg + G<\/b>). Hier fügen wir im Verweise<\/b>-Dialog (Menü-Eintrag Extras|Verweise<\/b>) zunächst einen Verweis auf die neue Bibliothek hinzu, die wir weiter unten in der Liste finden. Danach sieht die Liste der aktivierten Verweise wie in Bild 8 aus.<\/p>\n Bild 8: Verweis auf die neue Klasse<\/span><\/b><\/p>\n Schließlich schauen wir uns die so hinzugefügte Klasse im Objektkatalog an. Wählen Sie hier oben die Klasse CMD <\/b>aus, erhalten Sie die Ansicht aus Bild 9.<\/p>\n Bild 9: Die Klasse CMD im Objektkatalog<\/span><\/b><\/p>\n Neben der von uns angelegten Methode namens Meldung-Ausgeben<\/b> finden Sie hier noch einige weitere Einträge wie Equals<\/b>, GetHashCode<\/b>, GetType <\/b>oder ToString<\/b>.<\/p>\n Diese möchten wir noch loswerden. Dazu sind ein paar änderungen am Code unserer Klasse nötig. Genau genommen müssen wir dazu sogar noch eine weitere Klasse als Interface zum VB-Projekt hinzufügen. Das ist aber schnell erledigt, sodass der neue Code der Klasse insgesamt wie folgt aussieht:<\/p>\n Ohne weiter auf die Details einzugehen: Dadurch, dass wir nun mit einem Interface arbeiten, werden nur noch die tatsächlich in der Klasse implementierten Member auch im Objektkatalog abgebildet. Bevor wir das Projekt erneut kompilieren, fügen wir auch noch eine GUID hinzu. Diese ermitteln wir mit dem Tool von Visual Studio, das sie über den Menüeintrag Extras|GUID erstellen <\/b>öffnen (siehe Bild 10). Hier erstellen Sie mit einem Klick auf Neue GUID <\/b>zuerst eine neue GUID und kopieren diese mit der Schaltfläche Kopieren <\/b>in die Zwischenablage. Wenn Sie die Option wie in der Abbildung gewählt haben, können Sie die GUID direkt zwischen den beiden folgenden Zeilen des Interfaces einfügen:<\/p>\n Bild 10: GUID ermitteln<\/span><\/b><\/p>\n Danach ermitteln Sie eine weitere GUID, die Sie auf die gleiche Weise in die Implementierung einfügen:<\/p>\n Damit sorgen Sie dafür, dass die Assemblies immer an den gleichen Stellen in der Registry zu finden sind.<\/p>\n Nun wollen wir die DLL erneut erstellen (Menüeintrag Erstellen|Projektmappe neu erstellen<\/b>). Um das zu erledigen, ohne eine Fehlermeldung zu erhalten, sollten Sie alle Anwendungen schließen, mit deren VBA-Editor auf die zuletzt erstellte Version der DLL zugegriffen haben. Nach dem Erstellen öffnen wir dann erneut unsere Beispieldatenbank unter Access und binden wir diese dann erneut ein, sofern der Verweis noch nicht vorhanden ist. Im VBA-Editor schauen wir uns dann zunächst die Elemente an. Dort finden wir nur noch die von uns definierte Methode MeldungAusgeben <\/b>vor (siehe Bild 11).<\/p>\n Bild 11: DLL nur mit der von uns definierten Methode<\/span><\/b><\/p>\n Nun wollen wir auch noch testen, ob wir diese Methode auch unter VBA aufrufen können. Dazu legen Sie ein neues Standardmodul an und fügen die folgenden Zeilen hinzu:<\/p>\n Nach dem Aufruf dieser Methode erscheint die erwartete Meldung im VBA-Editor (siehe Bild 12).<\/p>\nDLL als Administrator erstellen<\/h2>\n
![\"Umbenennen](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_002.png\")
<\/p>\nPublic Class<\/span> CMD\r\nEnd Class<\/span><\/pre>\nEinfache Meldung ausgeben<\/h2>\n
Public Class<\/span> CMD\r\n Public <\/span>Sub MeldungAusgeben()\r\n End Sub\r\nEnd Class<\/span><\/pre>\nVerweis auf Bibliothek hinzufügen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_003.png\")
<\/p>\nImports System.Windows.Forms<\/pre>\n
Public Class<\/span> CMD\r\n Public <\/span>Sub MeldungAusgeben()\r\n MessageBox.Show(\"Dies ist eine Meldung von einer VB-DLL.\")\r\n End Sub\r\nEnd Class<\/span><\/pre>\nImports System.Runtime.InteropServices<\/pre>\n
<ClassInterface(ClassInterfaceType.AutoDual)>\r\nPublic Class<\/span> CMD\r\n ...\r\nEnd Class<\/span><\/pre>\nDLL-Klassen und -Methoden sichtbar machen<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_004.png\")
<\/p>\n![\"Registrieren](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_005.png\")
<\/p>\nErster Test der DLL<\/h2>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_006.png\")
<\/p>\n![\"Beim](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_008.png\")
<\/p>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_009.png\")
<\/p>\nMethode vorhanden<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_007.png\")
<\/p>\nMethoden per Interface einschränken<\/h2>\n
Imports System.Windows.Forms\r\nImports System.Runtime.InteropServices\r\n<InterfaceType(ComInterfaceType.InterfaceIsDual)>\r\nPublic <\/span>Interface ICMD\r\n Sub MeldungAusgeben()\r\nEnd Interface\r\n<ClassInterface(ClassInterfaceType.None)>\r\nPublic Class<\/span> CMD\r\n Implements ICMD\r\n Public <\/span>Sub MeldungAusgeben() Implements ICMD.MeldungAusgeben\r\n MessageBox.Show(\"Dies ist eine Meldung von einer VB-DLL.\")\r\n End Sub\r\nEnd Class<\/span><\/pre>\n![\"GUID](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_010.png\")
<\/p>\n<InterfaceType(ComInterfaceType.InterfaceIsDual)>\r\n<Guid(\"E5B3AD75-908B-419C-9969-F2E98FECA240\")>\r\nPublic <\/span>Interface ICMD\r\n...<\/pre>\n<ClassInterface(ClassInterfaceType.None)>\r\n<Guid(\"CD23B61E-2D47-484D-B0CB-1AA65CC968EA\")>\r\nPublic Class<\/span> CMD\r\n...<\/pre>\nNeuer Test<\/h2>\n
![\"DLL](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_011.png\")
<\/p>\nPublic Sub <\/span>TestDLL()\r\n Dim <\/span>objCMD As <\/span>CMD.CMD\r\n Set<\/span> objCMD = New<\/span> CMD.CMD\r\n objCMD.MeldungAusgeben\r\nEnd Sub<\/span><\/pre>\n![\"Testaufruf](\"..\/fileadmin\/_temp_\/2018_06\/pic_1167_012.png\")
<\/p>\n