![\"Erstellen](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_001.png\")
<\/p>\nCOM-Add-Ins sind Erweiterungen für Office-Anwendungen und ihre Entwicklungsumgebung, den VBA-Editor. Damit lassen sich Erweiterungen programmieren, die über die Benutzeroberfläche der jeweiligen Anwendung verfügbar gemacht werden und ihre Aufgabe mit oder ohne ein eigenes User Interface bereitstellen. COM-Add-Ins kann man jedoch nicht mit den Mitteln der Office-Anwendungen selbst programmieren. Dazu sind weitere Tools notwendig. Früher ging dies am einfachsten mit Visual Studio 6. Dieses ist jedoch spätestens seit der Einführung der 64-Bit-Versionen der Office-Anwendungen nicht mehr nutzbar, sodass Alternativen gefragt sind. Neben Visual Studio .NET, das ebenfalls das Erstellen von COM-Add-Ins erlaubt, erschien vor kurzer Zeit eine neue Alternative: twinBASIC. Ein Projekt von Wayne Phillips, das sich nicht nur anschickt, Nachfolger von Visual Studio 6 zu werden, sondern schon jetzt das Erstellen unter anderem von COM-Add-Ins ermöglicht. Dieser Artikel stellt die grundlegenden Techniken zum Erstellen eines Gerüsts für COM-Add-Ins vor, das wir in weiteren Artikeln mit praktischen Lösungen für die Erweiterung der Office-Anwendungen und auch des VBA-Editors nutzen werden.<\/b><\/p>\nVorbereitungen<\/h2>\n
Wie wir twinBASIC <\/b>herunterladen und betriebsbereit machen, beschreiben wir im Artikel twinBASIC: Visual Basic für die Zukunft <\/b>(www.vbentwickler.de\/310<\/b>).<\/p>\n
Nach dem Start von twinBASIC <\/b>finden wir auf der zweiten Seite des Startdialogs namens Samples <\/b>einige Beispielprojekte vor.<\/p>\nErstellen eines COM-Add-In-Projekts<\/h2>\n
Wir starten mit einer der praktischen Vorlagen für die Erstellung verschiedener Beispielprojekte, in diesem Fall Sample 5. MyCOMAddIn<\/b> (siehe Bild 1).<\/p>\n
<\/p>\n
Bild 1: Erstellen eines COM-Add-Ins auf Basis des passenden Beispiels<\/span><\/b><\/p>\n Ein Klick auf diese Schaltfläche erstellt ein neues Projekt, das zu diesem Zeitpunkt jedoch noch nicht gespeichert ist. Um dieses zu speichern, betätigen wir den Menübefehl File|Save Project<\/b>. Dies öffnet, da das Projekt noch ungespeichert ist, einen Save Project As…<\/b>-Dialog. Mit diesem navigieren wir zu dem gewünschten Zielordner und geben den Dateinamen für das Projekt ein, der die Dateiendung .twinproj <\/b>trägt (siehe Bild 2).<\/p>\n Bild 2: Festlegen des Speicherorts für die .twinproj-Datei<\/span><\/b><\/p>\n Schauen wir dann in das Verzeichnis, in dem wir das neue Projekt angelegt haben, stellen wir fest, dass hier tatsächlich nur eine Datei vorliegt – es gibt aktuell noch keine weiteren Elemente.<\/p>\n Damit kehren wir zurück zur twinBASIC<\/b>-Entwicklungsumgebung, die das neu erstellte Projekt anzeigt.<\/p>\n Das Projekt enthält zu diesem Zeitpunkt zwei Module:<\/p>\n Die wichtigste Frage, die wir beantworten müssen, bevor wir das Add-In überhaupt testweise erstellen, ist die nach der Anwendung, in der das Add-In seine Funktionen zur Verfügung stellen soll.<\/p>\n Aktuell gehen wir davon aus, dass es sich dabei um eine der folgenden Office-Anwendungen handelt:<\/p>\n Oder wollen wir das COM-Add-In sogar für mehrere Office-Anwendungen gleichzeitig verfügbar machen? Das ist möglich, aber es stellt sich die Frage, ob es Anwendungsfälle gibt, die in allen Office-Anwendungen nützlich sind. Tatsächlich gehen wir davon aus, dass ein COM-Add-In eher auf eine Office-Anwendung spezialisiert ist. Dennoch zeigen wir, wie wir das COM-Add-In für mehrere Office-Anwendungen gleichzeitig bereitstellen können.<\/p>\n Die zweite Frage, die sich stellt, ist die nach der Architektur der Office-Installation: Ist diese für 32-Bit- oder für 64-Bit ausgelegt? Wir befinden uns in einem Wandel, denn bis vor kurzer Zeit hat das Office-Setup standardmäßig die 32-Bit-Version von Office installiert. Mit Office 2016 und den entsprechenden Versionen unter Office 365 hat sich dies jedoch geändert. Hier landet nun standardmäßig die 64-Bit-Version auf dem Rechner.<\/p>\n Das Problem ist nun, dass auch COM-Add-Ins für die entsprechende Version, also 32-Bit oder 64-Bit, kompiliert werden müssen. Unter twinBASIC ist das ein kleines Problem, wenn auch mit gewissen Einschränkungen. Wir können zwar die entsprechende Zielversion (win32 <\/b>oder win64<\/b>) vor der Kompilierung auswählen. Allerdings ist twinBASIC nur für die 32-Bit-Version kostenlos. Wenn wir die 64-Bit-Version kompilieren, wird sowohl während der Kompilierung als auch bei Start des COM-Add-Ins jeweils ein Dialog des Herstellers mit dem twinBASIC<\/b>-Logo eingeblendet.<\/p>\n Für Entwicklungszwecke und zum Ausprobieren ist das kein Problem. Wir gehen jedoch davon aus, dass wir, wenn wir mit twinBASIC <\/b>erstellte Anwendungen beim Kunden einsetzen wollen, auch die anfallenden (überschaubaren) Lizenzgebühren gerne entrichten.<\/p>\n Wir wollen direkt einmal das vorgefertigte Beispiel ausprobieren und klicken nach der Auswahl der Zielversion (32-Bit oder 64-Bit) direkt auf die Schaltfläche Build <\/b>in der Menüleiste (siehe Bild 3).<\/p>\n Bild 3: Erstellen des COM-Add-Ins<\/span><\/b><\/p>\n Danach können wir das COM-Add-In in Excel und auch in Access ausprobieren. Wenn wir Excel öffnen, finden wir die Möglichkeit zum Aufrufen der Funktion des COM-Add-Ins im Ribbon unter twinBASIC Test<\/b>. Ein Klick auf die in diesem Tab enthaltene Schaltfläche zeigt ein Meldungsfenster an (siehe Bild 4).<\/p>\n Bild 4: Aufruf des COM-Add-Ins von Excel aus<\/span><\/b><\/p>\n Das gleiche Ergebnis erhalten wir mit diesem COM-Add-In auch, wenn wir Access öffnen.<\/p>\n Der erste Schritt der Anpassung des COM-Add-Ins soll sich auf die Anwendung beziehen, in welcher dieses angezeigt wird. Diese Einstellung nehmen wir im Modul DllRegistration <\/b>vor.<\/p>\n Hier finden wir den Code aus Listing 1. Wir sehen ganz oben, dass unter twinBASIC <\/b>Standardmodule in Module [Modulname] <\/b>und End Module <\/b>eingefasst werden müssen. Wir sehen außerdem einige Konstanten, welche Informationen enthalten, die in den beiden weiter unten definierten Funktionen zum Einsatz kommen. Die erste speichert den Namen des Projekts, der aus VBA.Compilation.CurrentProjectName <\/b>bezogen wird. Die Klasse Compilation <\/b>ist eine twinBASIC<\/b>-Erweiterung, die Informationen über das aktuelle Projekt liefert und deren Member wir beispielsweise wie in Bild 5 per IntelliSense abfragen können. In diesem Fall ermitteln wir den aktuellen Projektnamen. Wie wir den Projektnamen anpassen, zeigen wir weiter unten.<\/p>\n Bild 5: Die Compilation-Klasse per IntelliSense<\/span><\/b><\/p>\n Die zweite Konstante namens AddinClassName <\/b>erhält den Namen der Klasse des Add-Ins. Dieser sollte mit dem Namen der Klasse im anderen Modul des Projekts übereinstimmen, in diesem Fall MyCOMAddin<\/b>. Die nächste Konstante AddinQualifiedClassName <\/b>fügt die beiden vorher definierten Konstanten, also AddinProjectName <\/b>und AddinClassName <\/b>zusammen.<\/p>\n Schließlich folgen noch zwei Konstanten namens RootRegistryFolder_ACCESS <\/b>und RootRegistryFolder_EXCEL<\/b>, welche die Pfade zu den zu erstellenden Einträgen für das COM-Add-In in der Registry aufnehmen. Für Access entsteht so beispielsweise der folgende Wert für diese Konstante:<\/p>\n Warum machen wir in Zusammenhang mit der Installation eines COM-Add-Ins überhaupt so einen Wirbel um Registry-Einträge? Der Grund ist einfach: Die Office-Anwendungen scannen beim Starten einen bestimmten Bereich der Registry, wo die für die jeweilige Anwendung registrierten COM-Add-Ins aufgelistet werden. Die dort angegebenen DLLs werden beim Start der Anwendung ausgelesen und dort untergebrachte Schnittstellen für die Anpassung von Ribbondefinitionen angewendet.<\/p>\n Um zu prüfen, ob das soeben erstellte COM-Add-In seinen Platz in der Registry gefunden hat, brauchen wir eigentlich nicht die Registry zu öffnen, denn wir haben uns ja durch Starten der Anwendungen Access <\/b>und Excel <\/b>davon überzeugt, dass das COM-Add-In für die beiden Anwendungen installiert ist.<\/p>\n Dennoch schauen wir uns die Registry an, wobei wir diese mit dem Befehl RegEdit<\/b> über das Suchen<\/b>-Feld von Windows öffnen.<\/p>\n Hier navigieren wir zum folgenden Eintrag:<\/p>\n Dies ist beispielsweise der Eintrag für Excel. Für diesen wurden einige Werte hinterlegt (siehe Bild 6).<\/p>\n Bild 6: Das Add-In für Excel in der Registry<\/span><\/b><\/p>\n Diese haben die folgende Bedeutung:<\/p>\n Die Werte für FriendlyName <\/b>und Description <\/b>sowie den Speicherort der DLL finden wir nach der Installation des COM-Add-Ins beispielsweise für Excel im Optionen-Dialog im Bereich Add-Ins<\/b>.<\/p>\n Die einzelnen Werte haben wir in Bild 7 hervorgehoben.<\/p>\n Bild 7: COM-Add-Ins in den Excel-Optionen<\/span><\/b><\/p>\n Wählen wir hier im unteren Bereich für das Kombinationsfeld Verwalten <\/b>den Wert COM-Add-Ins <\/b>aus und klicken auf die Schaltfläche Los…<\/b>, finden wir den Dialog aus Bild 8 vor. Hier sehen wir auch den aktuellen Wert für die Eigenschaft Ladeverhalten<\/b>, in diesem Fall Beim Start laden<\/b>.<\/p>\n Bild 8: Der Dialog COM-Add-Ins<\/span><\/b><\/p>\n Nachdem wir uns nun mit der Bedeutung des Vorhandenseins gewisser Registry-Einträge beschäftigt haben, wollen wir uns ansehen, wie diese dorthin gelangen.<\/p>\n Diese Aufgabe übernimmt die Funktion DllRegisterServer <\/b>im Modul DllRegistration<\/b>. Diese Funktion erzeugt eine Instanz des Objekt wscript.shell<\/b>, welches beispielsweise die Methode RegWrite <\/b>zum Schreiben von Registry-Einträgen bereitstellt. Diese nutzen wir, um die benötigten Einträge mit den Werten, die teilweise aus den oben definierten Konstanten stammen, zur Registry hinzuzufügen.<\/p>\n Das alles geschieht unter Deaktivierung der eingebauten Fehlerbehandlung mit On Error Goto RegError<\/b>. Tritt beim Anlegen der Registry-Einträge ein Fehler auf, zeigt die Funktion ein Meldungsfenster mit Details zum aufgetretenen Fehler an.<\/p>\n Es gibt zwei Gelegenheiten, zu denen die Funktion DllRegister <\/b>aufgerufen wird. Die erste ist das Betätigen der Build<\/b>-Schaltfläche in der twinBASIC<\/b>-Entwicklungsumgebung.<\/p>\n Ob sie dadurch tatsächlich aufgerufen wird, können wir anschließend am Vorhandensein der dort definierten Registry-Einträge feststellen. Wir können aber auch einfach eine MsgBox<\/b>-Anweisung einbauen und uns beispielsweise den Pfad in der Registry ausgeben lassen, in welchen die Registry-Informationen geschrieben werden.<\/p>\n Der zweite Zeitpunkt, zu dem diese Funktion aufgerufen wird, ist die Registrierung auf dem jeweiligen Zielrechner mit der Anweisung RegSvr32.exe <\/b>entweder über die Eingabeaufforderung oder auch per Batch-Datei.<\/p>\n Wenn wir die COM-Add-In-Datei also auf einen anderen Rechner kopiert haben und diese installieren wollen, müssen wir diese mehr oder weniger von Hand registrieren, wenn wir nicht gerade ein Setup für das COM-Add-In erstellt haben. Wie wir ein solches Setup erstellen, erläutern wir noch in einem weiteren Beitrag.<\/p>\n Über die Eingabeaufforderung gelingt das wie folgt:<\/p>\n Bild 9: Installieren per Eingabeaufforderung<\/span><\/b><\/p>\n<\/ul>\n Wir sehen, dass wir die twinBASIC<\/b>-Funktion DllRegisterServer <\/b>auch von der Kommandozeile aus aufrufen können. Das eröffnet uns auch die Möglichkeit, dort weitere Mechanismen unterzubringen, die für die Verwendung des COM-Add-Ins noch hilfreich sein können – beispielsweise das Anlegen bestimmter Dateien mit Konfigurationsdateien, die Anzeige von Meldungen während der Installation et cetera.<\/p>\n Den Befehl Regsvr32.exe <\/b>können wir in eine Batch-Datei schreiben und diese dann im Administratormodus aufrufen. Diese Datei nennen wir einfach Register.bat<\/b>. Wenn wir diese Datei im gleichen Verzeichnis platzieren wie die zu registrierende Datei, brauchen wir noch nicht mal den Pfad zur zu registrierenden .dll<\/b>-Datei anzugeben, wie es eigentlich nötig wäre, wenn wir nicht in der Eingabeaufforderung zum Verzeichnis mit der .dll<\/b>-Datei navigiert hätten.<\/p>\n Wenn wir ein Element durch Hinzufügen von Einträgen zur Registry installieren, wollen wir dieses auch wieder deinstallieren können. Dazu können wir die Funktion DllUnregisterServer <\/b>nutzen. Der Aufbau dieser Funktion ist dem der Prozedur zum Hinzufügen der Registry-Einträge recht ähnlich. Allerdings nutzen wir hier nicht die Methode RegWrite <\/b>der Klasse wscript.shell<\/b>, sondern die Methode RegDelete<\/b>.<\/p>\n Hier sind nicht nur drei Aufrufe nötig, sondern noch ein weiterer. Beim Registrieren werden nämlich automatisch alle Ordner angelegt, die zu den hinzuzufügenden Registry-Einträgen führen – in diesem Fall der Ordner aus der Konstanten AddinQualifiedClassName<\/b>. Den so angelegten Ordner müssen wir beim Deinstallieren nach dem Löschen der eigentlichen Registry-Einträge separat wieder entfernen.<\/p>\n Der Rest läuft wie beim Anlegen der Registry-Einträge ab.<\/p>\n Wenn wir die Registrierung auf dem Zielrechner wieder aufheben wollen, können wir wie beim Registrieren vorgehen – wir rufen in der für den Administratorzugriff geöffneten Eingabeaufforderung den gleichen Befehl auf, diesmal allerdings mit dem Parameter -u<\/b>:<\/p>\n Wenn wir ein COM-Add-In für eine Anwendung registrieren, können wir dies unabhängig davon erledigen, ob die Zielanwendung aktuell geöffnet ist oder nicht. Die einzige Konsequenz, wenn die Anwendung geöffnet ist, ist folgende: Das COM-Add-In ist dann nicht sofort, sondern erst beim nächsten Öffnen der Anwendung verfügbar.<\/p>\n Beim Registrieren im Rahmen des Erstellens des COM-Add-Ins von der twinBASIC-Entwicklungsumgebung aus sollten wir die Zielanwendungen jedoch immer schließen. Ansonsten kann es vorkommen, dass beim Versuch, die bestehende Version der .dll<\/b>-Datei zu löschen und diese neu zu erstellen, ein Fehler auftritt, weil die .dll<\/b>-Datei gerade in Verwendung ist.<\/p>\n Wenn wir entschieden haben, für welche Anwendung das COM-Add-In zum Einsatz kommen soll, können wir die beiden Funktionen DllRegister <\/b>und DllUnregister <\/b>entsprechend anpassen. Wir können dann zuerst einen Satz von Registry-Informationen entfernen. Dann passen wir die Funktionen wie folgt an. Die Funktion DLLRegister<\/b> sieht dann wie in Listing 2 aus.<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>![\"Festlegen](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_002.png\")
<\/p>\nModule des Beispielprojekts<\/h2>\n
\n
Für welche Anwendung soll das COM-Add-In eingesetzt werden?<\/h2>\n
\n
Soll das COM-Add-In für eine 32-Bit- oder für eine 64-Bit-Anwendung kompiliert werden?<\/h2>\n
Schnellstart mit dem Beispiel-COM-Add-In<\/h2>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_003.png\")
<\/p>\n![\"Aufruf](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_004.png\")
<\/p>\nAnpassung der Zielanwendung<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_005.png\")
<\/p>\nHKCU\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\MyCOMAddin.MyCOMAddin\\<\/pre>\n
Wozu Registry-Einträge?<\/h2>\n
Computer\\HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Office\\Excel\\Addins\\MyCOMAddin.MyCOMAddin<\/pre>\n
![\"Das](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_006.png\")
<\/p>\n\n
![\"COM-Add-Ins](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_007.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_008.png\")
<\/p>\nFunktion zum Einrichten der Registry-Einträge<\/h2>\n
Wann wird DllRegisterServer aufgerufen?<\/h2>\n
\n
![\"Installieren](\"..\/fileadmin\/_temp_\/2022_02\/pic_311_009.png\")
<\/p>\nFunktion zum Entfernen der Registry-Einträge<\/h2>\n
Regsvr32 MyCOMAddin_win32.dll -u<\/pre>\n
Bedingungen für das Registrieren und Deregistrieren von COM-Add-Ins<\/h2>\n
Modul DLLRegistration auf die Zielanwendung anpassen<\/h2>\n
Public Function <\/span>DllRegisterServer() As Boolean<\/span>\r\n On Error GoTo<\/span> RegError\r\n Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n wscript.RegWrite RootRegistryFolder & \"FriendlyName\", AddinProjectName + \"_Friendly\", \"REG_SZ\"\r\n wscript.RegWrite RootRegistryFolder \"Description\", AddinProjectName + \"_Description\", \"REG_SZ\"\r\n wscript.RegWrite RootRegistryFolder & \"LoadBehavior\", 3, \"REG_DWORD\"\r\n Return True<\/span>\r\nRegError:\r\n MsgBox<\/span> \"DllRegisterServer -- An error occured trying to write to the system registry:\" & vbCrLf<\/span> & _\r\n Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n Return False<\/span>\r\nEnd Function<\/span><\/pre>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t