<\/p>\n
Der VBA-Editor hinkt Visual Studio um Lichtjahre hinterher. Doch es gibt gute Nachrichten: Mit einem COM-Add-In auf Basis von .NET können Sie auch den VBA-Editor noch um Funktionen erweitern. Das zeigen ja auch andere Werkzeugkästen wie etwa die MZ-Tools. Wir wollen in diesem Artikel einmal zeigen, wie Sie ein COM-Add-In in Visual Studio programmieren, das dann beim öffnen des VBA-Editors zu seiner Erweiterung zur Verfügung steht.<\/b><\/p>\n
In diesem Artikel schauen wir uns zunächst an, welche Schritte grundsätzlich zum Erstellen eines COM-Add-Ins für den VBA-Editor nötig sind. Die Funktion des COM-Add-Ins beschränken wir auf das Nötigste – darauf gehen wir dann in einem weiteren Artikel ein und fügen dem Add-In dann nützliche Funktionen hinzu.<\/p>\n
Visual Studio 2017 stellt zwar Projektvorlagen für COM-Add-Ins für die Office-Anwendungen Excel, Outlook, Word et cetera bereit, jedoch nicht für Access oder den VBA-Editor der Office-Anwendung. Also müssen wir uns selbst behelfen und die notwendigen Elemente selbst zusammenstellen.<\/p>\n
Dazu legen Sie unter Visual Studio zunächst ein neues Projekt mit der Vorlage Visual Basic|Windows Desk-top|Klassenbibliothek <\/b>an und speichern dieses unter dem Namen VBECOM-AddIn <\/b>(siehe Bild 1).<\/p>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_001.png\")
<\/p>\n
Bild 1: Anlegen des neuen Projekts<\/span><\/b><\/p>\n Damit erstellen Sie ein neues Projekt, dass zunächst lediglich die Klasse Class1.vb <\/b>enthält.<\/p>\n Danach fügen wir dem Projekt einige Verweise hinzu, wobei Sie jeweils über den Menüeintrag Projekt|Verweise hinzufügen… <\/b>starten. Hier wollen wir als einen Verweis auf die Extensibility<\/b>-Bibliothek hinzufügen. Diese finden wir nur über den Durchsuchen<\/b>-Dialog des Verweis-Managers, den Sie über die entsprechende Schaltfläche öffnen (siehe Bild 2).<\/p>\n Bild 2: Verwalten der Verweise<\/span><\/b><\/p>\n Hier finden Sie dann etwa unter dem Verzeichnis C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Visual Studio Tools for Office\\PIA\\Common <\/b>die Datei Extensibility.dll <\/b>(siehe Bild 3).<\/p>\n Bild 3: Auswahl der Datei Extensibility.dll<\/span><\/b><\/p>\n Achtung: Wenn Sie einfach Extensibility <\/b>in das Suchfeld eingeben, werden Sie vermutlich die falsche Version erwischen, was dazu führen kann, dass das Add-In nicht geladen werden kann!<\/p>\n Danach ergänzen wir das Projekt um weitere Verweise, wozu wir ebenfalls den Verweis-Manager <\/b>benötigen. Die weiteren Verweise finden Sie im Bereich Assemblys<\/b>, wo Sie am einfachsten den passenden Suchbegriff in das Suchen-Feld eingeben. Die erste so zu ergänzende Bibliothek heißt beispielsweise <\/p>\n Sie ist in zwei verschiedenen Verzeichnissen verfügbar, nämlich in C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Visual Studio Tools for Office\\PIA\\Office15 <\/b>und C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\Visual Studio Tools for Office\\PIA\\Office15<\/b>. Wir konnten keinen Unterschied bei den beiden DLLs feststellen. Es spielt also keine Rolle, welche Sie verwenden. Also wählen wir einfach einen der beiden aktuelleren Einträge aus (siehe Bild 4). Warum aber überhaupt einen Verweis auf die Access-Bibliothek, obwohl wir doch ein COM-Add-In für den VBA-Editor erstellen wollen Ganz einfach: So haben wir auch die Möglichkeit, einmal auf die Objekte der Access-Datenbank zuzugreifen, um gegebenenfalls etwa VBA-Klassen auf Basis von Tabellen oder Formularen erstellen zu lassen. Auf die gleiche Weise fügen wir nun auch noch Verweise auf die Bibliotheken Microsoft.Office.Interop.Access.Dao<\/b>, Microsoft.VBE.Interop <\/b>und Microsoft.VBE.Interop.Forms <\/b>hinzu. Außerdem benötigen wir etwa für die Anzeige von Meldungsfenstern noch den Namespace System.Windows.Forms<\/b>.<\/p>\n Bild 4: Einbinden des Namespaces Microsoft.Office.Interop.Access<\/span><\/b><\/p>\n Insgesamt sieht die Liste der Verweise nun wie in Bild 5 aus.<\/p>\n Bild 5: Liste der Verweise des Projekts<\/span><\/b><\/p>\n Nun fügen wir dem Projekt eine neue Klasse namens Connect <\/b>hinzu. Dazu wählen Sie im Kontextmenü des Eintrags VBECOMAddIn <\/b>des Projektmappen-Explorers den Befehl Hinzufügen|Klasse…<\/b> aus.<\/p>\n Für die neue Klasse vergeben Sie im nun erscheinenden Dialog Neues Element hinzufügen <\/b>den Namen Connect <\/b>(siehe Bild 6).<\/p>\n Bild 6: Hinzufügen der Klassendatei VBECOMAddIn<\/span><\/b><\/p>\n Der neuen Klassendatei fügen wir nun zunächst die Verweise auf die Namespaces der soeben hinzugefügten Bibliotheken hinzu, und zwar im Kopf des Moduls:<\/p>\n Danach folgt ein Schritt, mit dem wir die Schnittstelle Extensibility.IDTExtensibility2 <\/b>für die Klasse Connect <\/b>implementieren. Dazu fügen wir in der Zeile unterhalb der Zeile Public Class Connect<\/b> die Anweisung Implements <\/b>ein und ergänzen dann wie in Bild 7 zu erkennen auf Implements Extensibility.IDTExtensibility2<\/b>.<\/p>\n Bild 7: Implementieren der Schnittstelle Extensibility.IDTExtensibility2<\/span><\/b><\/p>\n Diese Anweisung wird nun noch rot unterstrichen markiert. Der Grund ist einfach: Wir haben zwar angegeben, dass wir die Schnittstelle implementieren wollen, allerdings haben wir nicht alle Member dieser Schnittstelle implementiert. Einen Hinweis darauf liefert auch die Fehlerliste (siehe Bild 8).<\/p>\n Bild 8: Fehlende Member der Implementierung von Extensibility.IDTExtensibility2<\/span><\/b><\/p>\n Diesen Fehler können wir allerdings recht schnell beheben. Dazu klicken Sie zunächst mit der rechten Maustaste auf den markierten Code und wählen aus dem Kontextmenü den Eintrag Schnellaktionen und Refactorings… <\/b>aus. Daraufhin erscheint eine Auswahl mit zwei Möglichkeiten, von denen wir den zweiten Eintrag namens Schnittstelle implementieren <\/b>auswählen. Dies zeigt alle Member an, die durch diesen Schritt automatisch zur Klasse hinzugefügt würden (siehe Bild 9).<\/p>\n Bild 9: Implementieren per Schnellaktionen und Refactorings<\/span><\/b><\/p>\n Wählen Sie diesen Eintrag aus, ergänzt diese Schnellaktion die Klasse wie in Bild 10.<\/p>\n Bild 10: Die Klasse mit allen Membern der Implementierung der Schnittstelle Extensibility.IDTExtensibility2<\/span><\/b><\/p>\n Nun benötigen wir eine eindeutige GUID, mit der wir das Add-In versehen. Diese ermitteln wir, indem wir den Menüpunkt Extras|GUID erstellen <\/b>aufrufen. Im nun erscheinenden Dialog wählen wir die letzte Option aus und klicken zum Erstellen der neuen GUID auf die Schaltfläche Neue GUID<\/b> (siehe Bild 11).<\/p>\n <\/p>\n Bild 11: Ermitteln einer neuen GUID<\/span><\/b><\/p>\n Dann kopieren Sie diese mit der Schaltfläche Kopieren <\/b>in die Zwischenablage. Die GUID hat nicht exakt die Form, die wir benötigen, sodass wir diese noch etwas anpassen müssen.<\/p>\n Dann fügen wir diese in die Attribut-Klasse ComVisible <\/b>direkt über der Zeile Public Class Connect <\/b>ein und legen die ProgID <\/b>auf VBECOMAddIn.Connect <\/b>fest, also auf Die hier angegebene GUID merken wir uns, da wir diese später noch für verschiedene Registry-Einträge benötigen.<\/p>\n Innerhalb des Klassenmoduls deklarieren wir zwei Variablen, die erstens einen Verweis auf den VBA-Editor (VBE<\/b>) und das Add-In (AddIn<\/b>) aufnehmen sollen:<\/p>\n Danach ersetzen wir in der Methode OnConnection <\/b>die Anweisung Throw New NotImplementedException() <\/b>durch die Zeilen aus Listing 1.<\/p>\n Listing 1: Ereignisprozedur beim Verbinden<\/span><\/b><\/p>\n Die Methode erledigt gleich mehrere Schritte. Als Erstes werfen wir allerdings einen Blick auf die Parameter der Methode. Der erste Parameter namens Application <\/b>liefert einen Verweis auf die aufrufende Anwendung. Der dritte heißt AddInInst <\/b>und liefert einen Verweis auf das Add-In selbst.<\/p>\n Wir konvertieren die damit gelieferten Verweise mit der DirectCast<\/b>-Methode in die Typen VBE <\/b>und AddIn<\/b>. Danach prüfen wir den Inhalt des zweiten Parameters namens ConnectMode<\/b>. Dieser kann verschiedene Werte liefern, zum Beispiel ext_cm_Startup <\/b>oder ext_cm_AfterStartup<\/b>. Diese haben die folgende Bedeutung:<\/p>\n Wir wollen zum Testen in beiden Fällen jeweils ein Meldungsfenster ausgeben, dass angibt, mit welchem Wert für den Parameter ConnectMode <\/b>das Add-In gestartet wurde.<\/p>\n Für die Methode OnStartupComplete <\/b>fügen wir ebenfalls die Methode MessageBox.Show <\/b>ein:<\/p>\n In den übrigen Methoden entfernen wir jeweils die Anweisung Throw New NotImplementedException()<\/b>. Dies reicht allerdings noch nicht aus, um das Add-In auszuprobieren.<\/p>\n Danach öffnen Sie die Eigenschaften des Projekts über den Eintrag My Project <\/b>des Projektmappen-Explorers. Hier prüfen Sie zunächst, ob der Assemblyname und der Stammnamespace die gleichen Bezeichnungen aufweisen – in diesem Fall VBECOMAddIn<\/b> (siehe Bild 12).<\/p>\n Bild 12: Prüfen der Bezeichnungen von Assembly und Stammnamespace<\/span><\/b><\/p>\n Nach diesem Schritt stellen wir auch noch für das Add-In ein, dass es für COM-Interop registriert werden soll, und zwar im Bereich Kompilieren <\/b>der Eigenschaften des Projekts (Bild 13).<\/p>\n Bild 13: Registrierung für COM-Interop aktivieren<\/span><\/b><\/p>\n Im gleichen Bereich prüfen Sie auch noch, ob die Eigenschaft Ziel-CPU <\/b>den Wert AnyCPU <\/b>aufweist und korrigieren diesen gegebenenfalls.<\/p>\n Außerdem kontrollieren wir, ob die Option Assembly signieren <\/b>im Bereich Signierung<\/b> der Eigenschaften des Projekts deaktiviert ist (siehe Bild 14).<\/p>\n Bild 14: Deaktivierung der Signierung der Assembly<\/span><\/b><\/p>\n An dieser Stelle können wir das Projekt bereits erstellen, und zwar über den Menübefehl Erstellen|Projektmappe erstellen<\/b>.<\/p>\n Gegebenenfalls schlägt dies jedoch mit der Fehlermeldung aus Bild 15 fehl. Wir benötigen also Administrator-Berechtigungen, um das Add-In zu erstellen. Dazu schließen Sie Visual Studio und öffnen es anschließend als Administrator. Wenn Sie eine Verknüpfung zu Visual Studio in der Taskleiste haben, können Sie hier zuerst das Kontextmenü des Taskleisten-Eintrags öffnen und dann das Kontextmenü des Eintrags Visual Studio 2017<\/b>. Hier finden Sie dann den Befehl Als Administrator ausführen<\/b>, mit dem Sie Visual Studio als Administrator starten (siehe Bild 16). In diesem Modus können Sie das Add-In dann ohne Probleme erstellen. <\/p>\n Bild 15: öffnen von Visual Studio als Administrator<\/span><\/b><\/p>\n Bild 16: Fehlermeldung beim Erstellen des Projekts ohne Administrator-Berechtigungen<\/span><\/b><\/p>\n Damit sind die Arbeiten in Visual Studio bereits abgeschlossen und wir können uns den Einträgen für die Registry widmen.<\/p>\n Damit der VBA-Editor überhaupt bemerkt, dass Sie sich die Mühe gemacht haben, ein neues Add-In anzulegen, das die Funktionen des VBA-Editors ergänzen soll, nehmen Sie bestimmte Einträge in der Windows-Registry vor. Die betroffenen Bereiche der Registry werden beim Start des VBA-Editors standardmäßig durchsucht und die dort gefundenen Einträge berücksichtigt. Für interne Zwecke reicht es aus, wenn wir die notwendigen Registry-Einträge halbmanuell eintragen. Wenn Sie ein Add-In weitergeben möchten, sollten Sie es als Setup verpacken, aber diesen Schritt wollen wir an dieser Stelle noch nicht gehen. Halbmanuell heißt, dass wir nicht direkt die Einträge im Registry-Editor vornehmen, sondern diese in eine .reg<\/b>-Datei schreiben, die wir dann ausführen und so die Einträge zur Registry hinzufügen.<\/p>\n Die .reg<\/b>-Datei legen Sie als einfache Textdatei an, die Sie anschließend umbenennen – beispielsweise in VBECOMAddIn.reg<\/b>. Diese enthält zunächst einige Einstellungen, die angeben, welche Beschreibung für das Add-In hinterlegt werden soll, wie das Ladeverhalten aussieht und wie der Name des Add-Ins ist:<\/p>\n Wenn Sie das Add-In nicht VBECOMAddIn <\/b>genannt haben oder wenn Sie weitere Add-Ins mit anderen Namen erstellen, müssen Sie VBECOMAddIn <\/b>entsprechend ersetzen. Für LoadBehavior <\/b>können Sie folgende Werte angeben:<\/p>\n Bild 17: Unser Add-In nach dem Start des VBA-Editors mit der Einstellung 0 für die Registry-Eigenschaft LoadBehavior<\/span><\/b><\/p>\n Bild 18: Unser Add-In nach dem Start des VBA-Editors mit der Einstellung 1 für die Registry-Eigenschaft LoadBehavior<\/span><\/b><\/p>\n In der Registry sieht der Bereich mit den soeben beschriebenen Einträgen wie in Bild 19 aus.<\/p>\n Bild 19: VBE-Bereich der Registry mit unserem Add-In<\/span><\/b><\/p>\n Mit diesen Registry-Informationen allein wird das Add-In jedoch noch nicht gestartet. Wir benötigen noch weitere Einträge. In diesen müssen wir die weiter oben für die Klasse Connect <\/b>ermittelte GUID angeben und diese mit dem soeben definierten Schlüssel VBECOMAddIn.Connect <\/b>verknüpfen. Das erledigen wir mit den folgenden Zeilen, die wir der oben begonnenen Registry-Datei VBECOMAddIn.reg <\/b>hinzufügen. Hier ist besonders wichtig, dass Sie den Pfad der DLL-Datei exakt wie nachfolgend beschrieben angeben und diesen natürlich an den von Ihnen verwendeten Pfad anpassen:<\/p>\n Nun speichern Sie Registry-Datei unter VBECOMAddIn.reg <\/b>und führen diese mit einem Doppelklick aus. Dabei erscheint erst eine Rückfrage und dann schließlich die Bestätigung über den Eintrag der Informationen in die Registry (siehe Bild 20).<\/p>\n Bild 20: Meldungen beim Eintragen der Informationen in die Registry<\/span><\/b><\/p>\n Dabei entsteht zunächst der Registry-Eintrag aus Bild 21. Dieser ist die genaue Zuordnung der GUID zu der dazu gehörenden Bibliothek, also unserer Add-In-DLL. Für den Schlüssel VBECOMAddIn.Connect <\/b>wird hierbei das Element CLSID <\/b>auf den Wert der GUID festgelegt.<\/p>\n Bild 21: Die Verknüpfung zwischen GUID und Klasse<\/span><\/b><\/p>\n Schließlich kommen noch einige Informationen wie in Bild 22 hinzu. Besonders wichtig ist hier, dass die Eigenschaft CodeBase <\/b>den Pfad zur erzeugten DLL enthält. Sollte dieser nicht vorhanden sein, fügen Sie ihn noch hinzu.<\/p>\n Bild 22: Werte für das Registry-Element InprocServer32<\/span><\/b><\/p>\n Wir haben dem Add-In Meldungen hinzugefügt, die erstens in der Methode OnConnection <\/b>ausgeführt werden (hier gleich zwei) und zweitens in der Methode OnStartupComplete<\/b>. Wenn Sie nun nach dem Erstellen des Projekts und dem Eintragen der Registry-Informationen Access und dann den VBA-Editor öffnen, geschieht erst einmal nichts. Kein Wunder, denn wir haben die Eigenschaft LoadBehavior <\/b>in der Registry zunächst auf den Wert 0 <\/b>eingestellt. Dadurch werden die Eigenschaften Geladen\/Entladen <\/b>und Beim Start laden <\/b>für unser Add-In im Add-In-Manager zu Beginn erst einmal deaktiviert. Aktivieren Sie die Eigenschaft Geladen\/Entladen <\/b>nun wie in Bild 23, ändert sich der Wert in der Spalte Ladeverhalten <\/b>in der Liste der Add-Ins auf Geladen<\/b>.<\/p>\n Bild 23: Laden des Add-Ins<\/span><\/b><\/p>\n Schließen wir dann den Dialog, erscheint die Meldung, die durch den zweiten Case<\/b>-Zweig der Methode OnConnection <\/b>ausgelöst wird und die das Laden nach dem Starten der Anwendung aufzeigt. Der Wert des Registry-Eintrags LoadBehavior <\/b>wird nach dem Schließen von Access auf 2 <\/b>eingestellt, wodurch dieser im Anschluss wieder auf 0 <\/b>zurückgesetzt wird.<\/p>\n Nun öffnen wir Access und den VBA-Editor erneut und aktivieren im Add-In-Manager des VBA-Editors beide Optionen, nämlich Geladen\/Entladen <\/b>und Beim Start laden<\/b>. Schließen wir den Dialog, erscheint wieder die gleiche Meldung wie oben (also zweite Bedingung in OnStartupComplete<\/b>). LoadBehavior <\/b>hat nun den Wert 3<\/b>. Dieser bleibt nach dem Schließen von Access erhalten.<\/p>\n öffnen wir Access nun erneut und wechseln dann zum VBA-Editor, erscheint schon vor dem Anzeigen des VBA-Editors die Meldung, die wir in der Methode Startup <\/b>definiert haben und dann die der zweiten Bedingung der Methode OnStartupComplete<\/b>.<\/p>\n Erst dann erscheint der VBA-Editor. Damit kennen wir nun die grundlegenden Abläufe. Da das Add-In in der Regel auch direkt beim öffnen des VBA-Editors angezeigt werden soll, behalten wir den Wert 3 <\/b>für die Eigenschaft LoadBehavior <\/b>in der Registry bei.<\/p>\n Mit diesem Artikel haben wir die Grundlagen zum Erstellen eines COM-Add-Ins auf Basis von Visual Basic für den VBA-Editor erläutert. In weiteren Artikeln zeigen wir, wie Sie das Add-In im VBA-Editor aufrufen können, zum Beispiel durch die Auswahl von Menü-, Symbol- oder Kontextmenü-Einträgen oder auch durch Tastenkombinationen. Außerdem werden wir praktische Anwendungsfälle für den Einsatz von COM-Add-Ins im VBA-Editor liefern.<\/p>\n Enthaltene Beispieldateien:<\/p>\n VBECOMAddIn.zip<\/p>\nVerweise hinzufügen<\/h2>\n
![\"Verwalten](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_002.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_003.png\")
<\/p>\nWeitere Verweise hinzufügen<\/h2>\n
![\"Einbinden](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_004.png\")
<\/p>\n![\"Liste](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_005.png\")
<\/p>\nKlasse Connect erstellen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_006.png\")
<\/p>\nNamespaces hinzufügen<\/h2>\n
Imports Microsoft.Office.Interop\r\nImports Extensibility\r\nImports Microsoft.Office.Interop.Access\r\nImports Microsoft.Office.Interop.Access.Dao\r\nImports System.Windows.Forms\r\nImports System.Runtime.InteropServices\r\nImports Microsoft.Vbe.Interop\r\nImports Microsoft.Vbe.Interop.Forms<\/pre>\n
Extensibility-Schnittstelle implementieren<\/h2>\n
![\"Implementieren](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_007.png\")
<\/p>\n![\"Fehlende](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_008.png\")
<\/p>\n![\"Implementieren](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_009.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_010.png\")
<\/p>\nNeue GUID ermitteln<\/h2>\n
![\"Ermitteln](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_011.png\")
<\/p>\n<ComVisible(True<\/span>), Guid(\"6317A901-A2F4-490F-961C-9AE170B734CD\"), ProgId(\"VBECOMAddIn.Connect\")>\r\nPublic Class<\/span> Connect\r\n...\r\nEnd Class<\/span><\/pre>\nPrivate <\/span>_VBE As <\/span>VBE\r\nPrivate <\/span>_AddIn As <\/span>AddIn<\/pre>\nPublic Sub <\/span>OnConnection(Application As Object<\/span>, _\r\n ConnectMode As <\/span>ext_ConnectMode, AddInInst As Object<\/span>, _\r\n ByRef custom As <\/span>Array) Implements IDTExtensibility2.OnConnection\r\n Try\r\n _VBE = DirectCast(Application, VBE)\r\n _AddIn = DirectCast(AddInInst, AddIn)\r\n Select Case ConnectMode\r\n Case <\/span>Extensibility.ext_ConnectMode.ext_cm_Startup\r\n MessageBox.Show(\"Add-In geladen (Startup): \" & _AddIn.ProgId)\r\n Case <\/span>Extensibility.ext_ConnectMode.ext_cm_AfterStartup\r\n MessageBox.Show(\"Add-In geladen (AfterStartup): \" & _AddIn.ProgId)\r\n End Select<\/span>\r\n Catch ex As <\/span>Exception\r\n MessageBox.Show(ex.ToString())\r\n End Try\r\nEnd Sub<\/span><\/pre>\n\n
Public Sub <\/span>OnStartupComplete(ByRef custom As <\/span>Array) Implements IDTExtensibility2.OnStartupComplete\r\n MessageBox.Show(\"Add-In geladen (OnStartupComplete): \" & _AddIn.ProgId)\r\nEnd Sub<\/span><\/pre>\nEigenschaften des Projekts einstellen<\/h2>\n
![\"Prüfen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_012.png\")
<\/p>\n![\"Registrierung](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_013.png\")
<\/p>\n![\"Deaktivierung](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_014.png\")
<\/p>\nProjekt erstellen<\/h2>\n
![\"öffnen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_016.png\")
<\/p>\n![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_015.png\")
<\/p>\nRegistry-Einträge anlegen<\/h2>\n
Windows Registry Editor Version 5.00\r\n[HKEY_CURRENT_USER\\Software\\Microsoft\\VBA\\VBE\\6.0\\Addins\\VBECOMAddIn.Connect]\r\n\"CommandLineSafe\"=dword:00000000\r\n\"Description\"=\"Grundgerüst für ein COM-Add-In für den VBA-Editor\"\r\n\"LoadBehavior\"=dword:00000000\r\n\"FriendlyName\"=\"VBECOMAddIn\"\r\n...<\/pre>\n
\n
![\"Unser](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_017.png\")
<\/p>\n![\"Unser](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_018.png\")
<\/p>\n![\"VBE-Bereich](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_019.png\")
<\/p>\nWeitere Registry-Einträge<\/h2>\n
[HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{6317A901-A2F4-490F-961C-9AE170B734CD}]\r\n@=\"VBECOMAddIn.Connect\"\r\n[HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{6317A901-A2F4-490F-961C-9AE170B734CD}\\Implemented Categories]\r\n[HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{6317A901-A2F4-490F-961C-9AE170B734CD}\\InprocServer32]\r\n@=\"mscoree.dll\"\r\n\"ThreadingModel\"=\"Both\"\r\n\"Class\"=\"VBECOMAddIn.Connect\"\r\n\"Assembly\"=\"VBECOMAddIn\"\r\n\"RuntimeVersion\"=\"v2.0.50727\"\r\n\"CodeBase\"=\"file:\/\/\/C:\\Users\\User\\Dropbox\\Daten\\Fachmagazine\\VisualStudioDatenbankentwicklung\\2018\\05\\VBAAddIn\\VBECOMAddIn\\VBECOMAddIn\\bin\\Debug\\VBECOMAddIn.dll\"\r\n[HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{6317A901-A2F4-490F-961C-9AE170B734CD}\\ProgId]\r\n@=\"VBECOMAddIn.Connect\"<\/pre>\n![\"Meldungen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_020.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_021.png\")
<\/p>\n![\"Werte](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_022.png\")
<\/p>\nAdd-In ausprobieren<\/h2>\n
![\"Laden](\"..\/fileadmin\/_temp_\/2019_01\/pic_1176_023.png\")
<\/p>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n