{"id":55000584,"date":"2008-04-01T00:00:00","date_gmt":"2021-02-11T21:20:20","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=584"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"COMAddIns_mit_Visual_Basic_2008_Express_Edition","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/COMAddIns_mit_Visual_Basic_2008_Express_Edition\/","title":{"rendered":"COM-Add-Ins mit Visual Basic 2008 Express Edition"},"content":{"rendered":"

\"\"<\/p>\n

Für die Erstellung von COM-Add-Ins brauchte man bislang teure Werkzeuge – so schien es zumindest. Mit ein wenig Bastelei können Sie diese jedoch auch mit der kostenlosen Express Edition von Visual Basic 2008 selber bauen. Dies eröffnet eine Menge Möglichkeiten – aber lesen Sie doch einfach selbst.<\/b><\/p>\n

COM-Add-Ins sind praktische Helferlein, die immer zu Diensten sind, wenn auch Access geöffnet ist. Im Beitrag Permanenter Query-Analyzer <\/b>(s. Shortlink 544) haben wir ein solches Tool auf Basis von Visual Basic 6.0 vorgestellt, das jedoch ausschließlich mit Access 2007 zusammenarbeitet. Im vorliegenden Beitrag lernen Sie die Grundlagen kennen, um solche Add-Ins unter .NET und ohne das kostenpflichtige Visual Studio 6.0, dafür aber mit dem kostenlosen Visual Basic 2008 Express Edition zu programmieren. Mit Visual Basic 2008 können Sie COM-Add-Ins für Office 2003 und Office 2007 programmieren.<\/p>\n

Voraussetzung für den Einsatz von COM-Add-Ins, die mit Visual Basic 2008 erstellt wurden, ist das .NET-Framework. Dieses ist jedoch genau wie Visual Basic 2008 Express Edition kostenlos, in der aktuellen Version genau genommen sogar zusammen mit diesem erhältlich. <\/p>\n

Das ist der gravierende Nachteil gegenüber VB6-COM-Add-Ins, die ja meist einfach in Form einer DLL daherkommen und lediglich registriert werden müssen, damit man sie einsetzen kann.<\/p>\n

Mit der Zeit wird man allerdings auch davon ausgehen können, dass beinahe jeder Windows-Rechner dieses Framework enthält. Außerdem sind COM-Add-Ins im Gegensatz zu den mit Access entwickelten Anwendungen ja auch eher Entwicklerwerkzeuge, die nicht für ein großes Zielpublikum vorgesehen sind, sondern nur für Entwickler, und deren Arbeitsrechner ist ja meist ohnehin mit halbwegs moderner Software ausgestattet.<\/p>\n

Ein COM-Add-In besteht aus einer oder mehreren Funktionen, die vom Benutzer über die Menüleiste beziehungsweise Symbolleiste oder bei Access 2007 über das Ribbon aufgerufen werden können und entweder reinen in dem Add-In enthaltenen Code ausführt oder aber auch eine eigene Benutzeroberfläche zur Verfügung stellen, wie es beim QueryAnalyzer der Fall ist.<\/p>\n

Im Hintergrund<\/b><\/p>\n

COM-Add-Ins implementieren eine spezielle Schnittstelle namens IExtensibility<\/b>. Diese liefert einige Ereignisprozeduren, die etwa beim Starten oder Schließen von Access ausgelöst werden. Damit Access beispielsweise beim Starten merkt, dass es da ein COM-Add-In gibt, dessen Ereignisse es feuern soll, trägt man das COM-Add-In in geeigneter Form in die Registry ein.<\/p>\n

Access liest beim Start nach, ob dort COM-Add-Ins eingetragen sind, merkt sich diese und ruft deren Ereignisse auf. Da diese die Schnittstelle IDTExtensibility<\/b> implementieren, das heißt, die dort definierten Methoden enthalten muss, benötigen Sie auch diese Schnittstelle in Form der Datei extensibility.dll<\/b>.<\/p>\n

Nun kommt diese Schnittstelle entweder mit einer der Vollversionen von Visual Studio 2008, für die man tief ins Portemonnaie greifen muss, oder mit einer älteren Version von Visual Studio. Und das war auch eines der größten Probleme beim Erstellen der Beispielanwendungen für diesen Beitrag: Es schien keine Möglichkeit zu geben, die extensibility.dll <\/b>bereitzustellen, da diese offiziell nicht für Visual Basic 2008-Projekte verfügbar ist.<\/p>\n

In der Annahme, dass die extensibility.dll <\/b>auch nur mit Wasser kocht und keine weiteren Funktionen außer der Definition der Schnittstelle besitzt, erfolgten einige erfolglose Versuche, die extensibility.dll <\/b>selbst herzustellen. Nach einigen Experimenten war es schließlich geschafft: Die in Visual Basic 2008 Express Edition fehlende IDTExtensibility2<\/b>-Schnittstelle ließ sich mit eben jenem Produkt nachbauen.<\/p>\n

Bevor wir zum Bau des eigentlichen COM-Add-Ins kommen finden Sie nachfolgend die Kurzanleitung zum Eigenbau der extensibility.dll<\/b>.<\/p>\n

IDTExtensibility2 selbst bauen<\/p>\n

Die folgenden Ausführungen gehen von einem System mit Office 2003 und Visual Studio 2008 Express Edition aus. Wer eine Version höher als die Standard Edition besitzt, dürfte die extensibility.dll <\/b>bereits auf dem System haben und kann diese gegebenenfalls auch weitergeben – in diesem Bereich konnten für diesen Beitrag mangels Professional-Version keine Nachforschungen angestellt werden. Mehr Informationen zu Visual Basic 2008 Express Edition <\/b>und zur Installation der Software erhalten Sie im Beitrag Visual Basic 2008 Express Edition <\/b>(Shortlink 580).<\/p>\n

Nach dem Ã-ffnen von Visual Studio legen Sie ein neues Projekt des Typs Klassenbibliothek <\/b>mit dem Namen Extensibility <\/b>an, ändern auch den Namen der einzigen vorhandenen Klasse von Class1.vb <\/b>in Extensibility.vb <\/b>und fügen den Code aus Listing 1 in die Klasse ein (den bestehenden Inhalt löschen Sie zuvor).<\/p>\n

Listing 1: Code der Schnittstellendatei Extensibility.vb<\/p>\n

Imports System.Runtime.InteropServices<\/pre>\n
p class=“quellcode-funktionssammlung“>Public Enum ext_ConnectMode<\/p>\n
 ext_cm_AfterStartup = 0<\/pre>\n
p class=“quellcode-funktionssammlung“> ext_cm_Startup = 1<\/p>\n
 ext_cm_External = 2<\/pre>\n
p class=“quellcode-funktionssammlung“> ext_cm_CommandLine = 3<\/p>\n
 ext_cm_Solution = 4<\/pre>\n
p class=“quellcode-funktionssammlung“> ext_cm_UISetup = 5<\/p>\n
End Enum<\/pre>\n
p class=“quellcode-funktionssammlung“>Public Enum ext_DisconnectMode<\/p>\n
 ext_dm_HostShutdown = 0<\/pre>\n
p class=“quellcode-funktionssammlung“> ext_dm_UserClosed = 1<\/p>\n
 ext_dm_UISetupComplete = 2<\/pre>\n
p class=“quellcode-funktionssammlung“> ext_dm_SolutionClosed = 3D<\/p>\n
End Enum<\/pre>\n
p class=“quellcode-funktionssammlung“><ComImport(), _<\/p>\n
 Guid("B65AD801-ABAF-11D0-BB8B-00A0C90F2744"), _<\/pre>\n
p class=“quellcode-funktionssammlung“> TypeLibType(TypeLibTypeFlags.FAggregatable Or TypeLibTypeFlags.FHidden), _<\/p>\n
 InterfaceType(ComInterfaceType.InterfaceIsIDispatch)> _<\/pre>\n
p class=“quellcode-funktionssammlung“>Public Interface IDTExtensibility2<\/p>\n
 <DispId(1)> Sub OnConnection( _<\/pre>\n
p class=“quellcode-funktionssammlung“> <[In](), MarshalAs(UnmanagedType.IDispatch)> ByVal Application As Object, _<\/p>\n
 <[In]()> ByVal ConnectMode As ext_ConnectMode, _<\/pre>\n
p class=“quellcode-funktionssammlung“> <[In](), MarshalAs(UnmanagedType.IDispatch)> ByVal AddInInst As Object, _<\/p>\n
 <[In](), MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_VARIANT)> ByRef custom As _<\/pre>\n
pre>System.Array)
\n <DispId(2)> Sub OnDisconnection( _p class=“quellcode-funktionssammlung“> <[In]()> ByVal RemoveMode As ext_DisconnectMode, _<\/p>\n
 <[In](), MarshalAs(UnmanagedType.SafeArray, safearraysubtype:=VarEnum.VT_VARIANT)> ByRef custom As _<\/pre>\n
pre>System.Array)
\n <DispId(3)> Sub OnAddInsUpdate( _p class=“quellcode-funktionssammlung“> <[In](), MarshalAs(UnmanagedType.SafeArray, safearraysubtype:=VarEnum.VT_VARIANT)> ByRef custom As _<\/p>\n
System.Array)\r\n <DispId(4)> Sub OnStartupComplete( _<\/pre>\n
p class=“quellcode-funktionssammlung“> <[In](), MarshalAs(UnmanagedType.SafeArray, safearraysubtype:=VarEnum.VT_VARIANT)> ByRef custom As _<\/p>\n
System.Array)\r\n <DispId(5)> Sub OnBeginShutdown( _<\/pre>\n
p class=“quellcode-funktionssammlung“> <[In](), MarshalAs(UnmanagedType.SafeArray, safearraysubtype:=VarEnum.VT_VARIANT)> ByRef custom As _<\/p>\n
System.Array)\r\nEnd Interface<\/pre>\n
p>Wenn Sie die Einfügemarke im Codefenster auf der Zeile Public Interface IDTExtensibility2 <\/b>positionieren, sollte das Eigenschaftsfenster den Wert True <\/b>für die Eigenschaft COM-sichtbar <\/b>anzeigen – sonst holen Sie dies nach.<\/p>\n
Damit nicht nur das Interface, sondern die gesamte Assembly COM-sichtbar ist, öffnen Sie mit einem Klick auf My Project <\/b>im Projektmappen-Explorer die Eigenschaften, zeigen dort die Registerseite Anwendung <\/b>an und klicken auf die Schaltfläche Assemblyinformationen… <\/b>Dort aktivieren Sie die Option Assembly COM-sichtbar machen<\/b> (siehe Bild 1).<\/p>\n
\"missing<\/p>\n
Bild 2: Signieren der Assembly<\/span><\/b><\/p>\n
Nun signieren Sie die Assembly noch: Dazu wechseln Sie erneut zu den Projekteigenschaften, zeigen dort die Registerseite Signierung <\/b>an, aktivieren die Option Assembly registrieren… <\/b>und wählen aus dem Kombinationsfeld Schlüsseldatei mit starkem Namen auswählen <\/b>den Eintrag <Neu…> <\/b>aus (siehe Bild 2). Folgen Sie den übrigen Anweisungen und schließen Sie den Vorgang ab.<\/p>\n
\"missing<\/p>\n
Bild 1: So machen Sie die Assembly COM-sichtbar<\/span><\/b><\/p>\n
<\/p>\n
Erstellen Sie dann das Projekt mit Erstellen|Extensibility erstellen<\/b>, <\/b>schließen Sie das Projekt mit dem Menüeintrag Datei|Projekt schließen <\/b>und geben Sie dort das Verzeichnis an, in dem Sie das Projekt speichern wollen – beispielsweise das dort üblicherweise vorgeschlagene C:\\Dokumente und Einstellungen\\André\\Eigene Dateien\\Visual Studio 2008\\Projects<\/b>.<\/p>\n
Nun müssen Sie die DLL noch registrieren, wozu Sie das Tool regasm.exe <\/b>mit dem folgenden Aufruf verwenden (<Pfad zur DLL> <\/b>entsprechend ersetzen):<\/p>\n
C:\\WINDOWS\\Microsoft.NET\\Framework\\v2.0.50727\\RegAsm.exe <Pfad zur DLL>\\Extensibility.dll" \/tlb \/codebase<\/pre>\n
Dies erzeugt eine zusätzliche Datei namens Extensibility.tlb<\/b> (die Endung tlb <\/b>steht für Type Library), die Informationen über die angebotenen Member der DLL enthält.<\/p>\n
Fertig – die Arbeiten an der Extensibility.dll <\/b>sind beendet.<\/p>\n
COM-Add-In Basisrezept<\/b><\/p>\n
Dann kann es losgehen – die Schritte, die zu einer herkömmlichen COM-DLL führen, finden Sie hier in Kurzform:<\/p>\n
Legen Sie mit der Vorlage Klassenbibliothek<\/b> ein neues Projekt namens aiuCOMAddIn <\/b>an und benennen Sie die automatisch erzeugte Klasse in aiuCOMAddIn.vb <\/b>um. Die Klasse enthält nun diese beiden Zeilen:<\/p>\n
Public Class aiuCOMAddIn\r\nEnd Class<\/pre>\n
Stellen Sie dem Public-Schlüsselwort den Ausdruck <ComClass()> <\/b>voran. Visual Studio zeigt den Klassennamen aiuCOMAddIn <\/b>nun unterschlängelt an. Wenn Sie mit Ansicht|Fehlerliste <\/b>die Fehlerliste einblenden, sehen Sie den Grund: Es fehlt ein öffentlicher Member, damit von außen via COM auf die Klasse zugegriffen werden kann.<\/p>\n
Das bedeutet nichts weiter, als dass eine Methode fehlt, die etwa Access aufrufen kann, wenn es startet und dies dem Add-In mitteilen möchte (dazu fehlt freilich noch ein passender Eintrag in der Registry, aber dazu später mehr).<\/p>\n
Dieser Member ist eine der fünf Prozeduren, die es auf Basis der Schnittstelle IDTExtensibility2 <\/b>zu implementieren gilt. Und dazu muss man der Klasse erst einmal bekanntgeben, dass sie dies überhaupt tun soll. Dazu brauchen Sie zunächst einen Verweis auf die soeben erstellte Schnittstellenklasse Extensibility.dll<\/b>.<\/p>\n
Um diesen hinzuzufügen, öffnen Sie aus dem Projektmappen-Explorer den Eintrag My Project <\/b>und wechseln dort zur Registerseite Verweise<\/b>. Mit einem Klick auf Hinzufügen <\/b>öffnen Sie den Dialog Verweis hinzufügen<\/b>. Dort wechseln Sie auf Durchsuchen <\/b>und wählen die zuvor frisch erzeugte Extensibility.DLL <\/b>aus. Wechseln Sie dann zur Datei aiuCOMAddIn.vb <\/b>und geben Sie dort in die noch leere Klasse die folgende Zeile ein:<\/p>\n
Implements Extensibility.IDTExtensibility2<\/pre>\n
Visual Studio wird nun automatisch die Ereignisprozeduren der Schnittstelle hinzufügen (siehe Bild 3).<\/p>\n
\"missing<\/p>\n
Bild 3: Die Schnittstelle Extensibility.IDTExtensibility2 mit ihren Ereignisprozeduren<\/span><\/b><\/p>\n
Die Methode OnConnection <\/b>wird beim Ã-ffnen der Client-Anwendung, die auf das COM-Add-In zugreifen soll, ausgelöst. Ergänzen Sie diese durch eine einfache MsgBox<\/b>-Anweisung:<\/p>\n
Public Sub OnConnection(...) _\r\nImplements Extensibility._\r\nIDTExtensibility2.OnConnection\r\nMsgBox("aiu")\r\nEnd Sub<\/pre>\n
Schließen und speichern Sie das Projekt nun im gewünschten Verzeichnis, öffnen Sie es erneut und erstellen Sie es mit Projekt|aiuCOMAddIn erstellen<\/b>. Nun fehlen noch zwei kleine Schritte. Als Erstes registrieren Sie das COM-Add-In in der Eingabeaufforderung mit dieser Anweisung: <\/p>\n
C:\\WINDOWS\\Microsoft.NET\\Framework\\v2.0.50727\\RegAsm.exe <Pfad zur DLL>\\aiuCOMAddIn.dll" \/tlb \/codebase<\/pre>\n
Anschließend erzeugen Sie noch einen Registry-Eintrag, den Access beim Ã-ffnen ausliest und auf eventuell einzubindende COM-Add-Ins untersucht.<\/p>\n
Den Registry-Eintrag fügen Sie ein, indem Sie die Zeilen aus Listing 2 in eine Datei namens aiuCOMAddIn.reg <\/b>eintragen und diese ausführen. Der letzte Teil in den eckigen Klammern besteht aus dem Projektnamen sowie der Klasse, welche die IDTExtensibility2<\/b>-Schnittstelle implementiert.<\/p>\n
Listing 2: Das Ausführen einer Datei namens QueryAnalyzer.reg mit diesem Inhalt registriert das COM-Add-In.<\/p>\n
Windows Registry Editor Version 5.00\r\n[HKEY_CURRENT_USER\\Software\\Microsoft\\Office\\Access\\Addins\\aiuCOMAddIn.aiuCOMAddIn]\r\n"LoadBehavior"=dword:00000003\r\n"FriendlyName"="aiuCOMAddIn"\r\n"Description"="aiuCOMAddIn ist ein Beispiel für das Erstellen von COM-Add-Ins mit Visual Basic 2008 Express Edition."<\/pre>\n
LoadBehavior <\/b>gibt durch den Wert 3 <\/b>an, dass das COM-Add-In sofort beim Start von Access geladen werden soll, der Rest dient der schicken Anzeige in der Add-In-Liste von Access.<\/p>\n
Die Registrierung erledigen Sie durch einen Doppelklick auf den Dateinamen aiuCOMAddIn.reg <\/b>und anschließendes Bestätigen der dadurch angezeigten Meldungen. Das Resultat sieht wie in Bild 4 aus.<\/p>\n
\"missing<\/p>\n
Bild 4: Dieser Registry-Eintrag sorgt dafür, dass Access das Add-In aiuCOMAddIn beim Start lädt.<\/span><\/b><\/p>\n
Nun steht einem ersten Aufruf durch das Ã-ffnen von Access nichts mehr im Wege.<\/p>\n
Im Fehlerfall<\/b><\/p>\n
Unbehandelte Fehler werden vom COM-Add-In nicht gemeldet. Wenn das COM-Add-In sich jedoch entgegen den Erwartungen unter Access nicht mehr meldet, schauen Sie in der Registry nach, ob es den Wert des Attributs LoadBehavior <\/b>auf 2 <\/b>eingestellt hat – in dem Fall ist ein Fehler aufgetreten und Access hat den Registry-Eintrag so eingestellt, dass das Add-In nicht mehr beim Start geladen wird.<\/p>\n
Óndern Sie dies, indem Sie den Wert zurück auf 3 <\/b>stellen – das geht am einfachsten durch einen erneuten Doppelklick auf die Datei aiuCOMAddIn.reg<\/b>.<\/p>\n
Eine einfache Fehlerbehandlung realisieren Sie folgendermaßen, wobei der Teil, in dem Sie einen Fehler erwarten, sich zwischen Try <\/b>und Catch <\/b>befindet und die Ausgabe einer entsprechenden Meldung zwischen der Catch<\/b>– und der End Try<\/b>-Zeile:<\/p>\n
Try\r\nMsgBox(1 \/ 0)\r\nCatch e As Exception\r\nMsgBox(e.Message)\r\nEnd Try<\/pre>\n
Für weitere Informationen zu dieser Vorgehensweise konsultieren Sie einfach die Visual Basic 2008-Onlinehilfe, indem Sie das gewünschte Schlüsselwort markieren und die Taste F1 <\/b>betätigen.<\/p>\n
Menüeintrag zu Access hinzufügen<\/b><\/p>\n
Bevor Sie irgendwelche Funktionen des COM-Add-Ins von Access aus aufrufen können, brauchen Sie entsprechende Einträge in einer der Menü- oder Symbolleisten. <\/p>\n
Nehmen wir an, Sie möchten einen Eintrag zum Ansicht-Menü hinzufügen. Dann brauchen Sie:<\/p>\n