{"id":55001555,"date":"2025-08-01T00:00:00","date_gmt":"2025-08-03T11:25:37","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1555"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Suchen_und_Ersetzen_mit_COMAddIn","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Suchen_und_Ersetzen_mit_COMAddIn\/","title":{"rendered":"Suchen und Ersetzen mit COM-Add-In"},"content":{"rendered":"

\"\"Im Beitrag „Besserer Suchen und Ersetzen-Dialog“ haben wir den Dialog zum Suchen und Ersetzen in Access-Formularen nachgebaut und um einige Features ergänzt. Nun wollen wir unseren selbst gebauten Dialog noch für jede Access-Anwendung verfügbar machen. Was liegt da näher, als diesen über das Ribbon aufzurufen? Um eine solche Erweiterung für jede geöffnete Anwendung verfügbar zu machen und so flexibel wie möglich zu sein, verwenden wir dazu ein COM-Add-In. Dieses enthält lediglich die Erweiterung des Ribbons um die benötigten Befehlsschaltflächen sowie den Code, um von dort aus den „Suchen und Ersetzen“-Dialog zu starten.<\/b><\/p>\n

COM-Add-Ins erstellen mit twinBASIC<\/h2>\n

Unsere erste Wahl für das komfortable Erstellen von COM-Add-Ins für Microsoft Access ist twinBASIC. Diese Entwicklungsumgebung ist in der 32-Bit-Version kostenlos und 64-Bit-DLLs können ebenfalls damit erstellt werden – in der kostenlosen Version erscheint hier allerdings ein Splash-Screen des Herstellers.<\/p>\n

Den jeweils aktuellen Release kann man hier herunterladen:<\/p>\n

https:\/\/github.com\/twinbasic\/twinbasic\/releases<\/pre>\n
Hier klickt man auf den gewünschten Release und lädt beispielsweise für den Release mit der Nummer 784 die Datei twinBASIC_IDE_BETA_784.zip <\/b>herunter.<\/p>\n
Den Inhalt entpackt man in ein neues, leeres Verzeichnis. Es ist keine weitere Installation notwendig, wir brauchen einfach nur die Datei twinBASIC.exe <\/b>zu starten. Nach dem Start erscheint ein Startdialog, in dem wir zur Registerseite Samples wechseln. Hier finden wir den Eintrag Sample 5. MYCOMAddIn<\/b>, den wir doppelt anklicken (siehe Bild 1).<\/p>\n
\"Anlegen<\/p>\n
Bild 1: Anlegen eines COM-Add-In-Projekts mit Beispiel<\/span><\/b><\/p>\n
Danach erscheint ein weiterer Dialog namens twinBASIC New Project Options<\/b>. Hier passen wir den Projektnamen an, in diesem Fall auf amvSuchenUndErsetzen <\/b>(siehe Bild 2).<\/p>\n
\"Angeben<\/p>\n
Bild 2: Angeben des Projektnamens<\/span><\/b><\/p>\n
twinBASIC erstellt nun in wenigen Augenblicken das neue Projekt und öffnet das Modul MyCOMAddin.twin<\/b>.<\/p>\n
Verweise hinzufügen<\/h2>\n
Da wir ein COM-Add-In erstellen wollen, fügen wir diesem zunächst einen Verweis auf die Objektbibliothek von Microsoft Access hinzu.<\/p>\n
Dazu öffnen wir den References<\/b>-Bereich mit dem Menübefehl Project|References<\/b>… (siehe Bild 3).<\/p>\n
\"Öffnen<\/p>\n
Bild 3: Öffnen der Referenzen<\/span><\/b><\/p>\n
Dort angekommen, wechseln wir zur Registerseite Available COM References <\/b>und geben im Suchbereich microsoft access <\/b>ein. Dies bringt den Verweis auf die Bibliothek Microsoft Access 16.0 Object Library <\/b>zum Vorschein, die wir nun aktivieren (siehe Bild 4). Anschließend klicken wir auf Save Changes<\/b>.<\/p>\n
\"Hinzufügen<\/p>\n
Bild 4: Hinzufügen eines Verweises auf die Access-Bibliothek<\/span><\/b><\/p>\n
Einstellungen anpassen<\/h2>\n
Danach öffnen wir mit Project|Project Settings <\/b>weitere Einstellungen, wo wir jeweils den Namen unseres Projekts eingeben können (siehe Bild 5).<\/p>\n
\"Einstellen<\/p>\n
Bild 5: Einstellen von Name, Description und Application Title<\/span><\/b><\/p>\n
.twin-Datei umbenennen<\/h2>\n
Nun klicken wir mit der rechten Maustaste links auf den Eintrag Sources|MyCOMAddin.twin <\/b>und wählen aus dem Kontextmenü den Befehl Rename <\/b>aus (siehe Bild 6). Wir können den Namen von MyCOMAddin.twin <\/b>nun bearbeiten und ändern diesen auf SuchenUndErsetzen.twin<\/b>.<\/p>\n
\"Umbenennen<\/p>\n
Bild 6: Umbenennen der Code-Datei<\/span><\/b><\/p>\n
Achtung: <\/b>Die Datei muss zu diesem Zweck geschlossen sein.<\/p>\n
Prozeduren zum Registrieren des COM-Add-Ins<\/h2>\n
Wie sehen neben der frisch umbenannten Datei SuchenUndErsetzen.twin <\/b>noch eine weitere Datei namens DllRegistration.twin<\/b>. Wenn wir diese öffnen, sehen wir verschiedene Elemente, die wir durch den Inhalt aus Listing 1 ersetzen.<\/p>\n
Module DllRegistration\r\n     Const AddinProjectName As String<\/span> = VBA.Compilation.CurrentProjectName\r\n     Const AddinClassName As String<\/span> = \"SuchenUndErsetzen\"\r\n     Const AddinQualifiedClassName As String<\/span> = AddinProjectName & \".\" & AddinClassName\r\n     Const RootRegistryFolder As String<\/span> = \"HKCU\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\\" & AddinQualifiedClassName & \"\\\"\r\n     Public <\/span>Function 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, \"REG_SZ\"\r\n         wscript.RegWrite RootRegistryFolder & \"Description\", AddinProjectName, \"REG_SZ\"\r\n         wscript.RegWrite RootRegistryFolder & \"LoadBehavior\", 3, \"REG_DWORD\"\r\n         Return True<\/span>\r\n     RegError:\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\n     End Function\r\n     Public <\/span>Function DllUnregisterServer() As Boolean<\/span>\r\n         On Error GoTo<\/span> RegError\r\n         Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n         wscript.RegDelete RootRegistryFolder & \"FriendlyName\"\r\n         wscript.RegDelete RootRegistryFolder & \"Description\"\r\n         wscript.RegDelete RootRegistryFolder & \"LoadBehavior\"\r\n         wscript.RegDelete RootRegistryFolder\r\n         Return True<\/span>\r\n     RegError:\r\n         MsgBox<\/span> \"DllUnregisterServer -- An error occured trying to delete from the system registry:\" & vbCrLf<\/span> & _\r\n                 Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n         Return False<\/span>\r\n     End Function\r\nEnd Module<\/pre>\n
Listing 1: Prozeduren zum Registrieren des COM-Add-Ins<\/span><\/b><\/p>\n
Hier sehen wir verschiedene Elemente. Ganz oben finden wir einige Konstanten, die unter anderem mit dem Projektnamen gefüllt werden (AddinProjectName<\/b>) oder mit dem Namen der zu verwendenden Klasse (SuchenUndErsetzen<\/b>).<\/p>\n
Darunter finden wir zwei Funktionen. Diese Funktionen werden ausgeführt, wenn wir das COM-Add-In registrieren oder die Registrierung aufheben wollen, zum Beispiel über die Kommandozeile.<\/p>\n
Die erste Funktion DllRegisterServer <\/b>nimmt die für den Einsatz notwendigen Einträge in der Registry vor, die zweite Funktion DllUnregisterServer <\/b>entfernt diese wieder.<\/p>\n
Code der COM-DLL<\/h2>\n
Nun müssen wir nur noch den Code erstellen, mit dem wir die gewünschten Einträge zum Ribbon hinzufügen und dafür sorgen, dass das COM-Add-In überhaupt ausgeführt wird, wenn wir Access starten.<\/p>\n
Dazu benötigen wir die Schnittstelle IDTExtensibility<\/b>, die wir durch Hinzufügen mit dem Schlüsselwort Implements <\/b>zur Klasse SuchenUndErsetzen <\/b>bekannt geben.<\/p>\n
Außerdem benötigen wir noch eine zweite Schnittstelle, damit wir über eine Funktion die Ribbondefinition übergeben können. Diese machen wir durch Anhängen von Implements IRibbonExtensibility <\/b>und dem zusätzlichen Hinweis [WithDispathForwarding] <\/b>für die Klasse bekannt.<\/p>\n
IDTExensibility2-Schnittstelle implementieren<\/h2>\n
Durch das Implementieren diese Schnittstellen müssen wir die dadurch definierten Methoden, Ereignisse und Eigenschaften ebenfalls im Code implementieren. Bei der Schnittstelle IDTExtensibility2 <\/b>bedeutet dies, dass wir einige Ereignisprozeduren anlegen müssen, die beim Laden des COM-Add-Ins durch Access ausgelöst werden, andere werden zu anderen Zeitpunkten aktiviert. Die wichtigste für uns ist die Ereignisprozedur OnConnection<\/b>, die beim Start von Access ausgelöst wird und mit der Access uns mit dem Parameter Application <\/b>einen Verweis auf die aktuelle Access-Instanz übergibt. Diesen Verweis speichern wir in der Variablen objAccess<\/b>, damit wir später darüber auf die Access-Instanz zugreifen können. Das ist in diesem Fall streng genommen gar nicht nötig, aber wir führen diesen Code immer mit, weil er für die meisten COM-Add-Ins, die direkt Aktionen mit dem Access-Objekt ausführen sollen, nötig ist.<\/p>\n
Diesen Teil des Codes finden Sie in Listing 2.<\/p>\n
[ClassId(\"DC8E7154-FAC8-43B7-88E5-A93527539222\")]\r\nClass<\/span> SuchenUndErsetzen\r\n     Implements IDTExtensibility2\r\n     [WithDispatchForwarding]\r\n     Implements IRibbonExtensibility\r\n     Private <\/span>objAccess As <\/span>Access.Application\r\n     Private <\/span>objRibbon As <\/span>IRibbonUI\r\n     Sub OnConnection(ByVal Application As Object<\/span>, ByVal ConnectMode As <\/span>ext_ConnectMode, ByVal AddInInst As Object<\/span>, _\r\n             ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnConnection\r\n         Set<\/span> objAccess = Application\r\n     End Sub\r\n     Sub OnDisconnection(ByVal RemoveMode As <\/span>ext_DisconnectMode, ByRef custom As Variant<\/span>()) _\r\n             Implements IDTExtensibility2.OnDisconnection\r\n     End Sub\r\n     Sub OnAddInsUpdate(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnAddInsUpdate\r\n     End Sub\r\n     Sub OnStartupComplete(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnStartupComplete\r\n     End Sub\r\n     Sub OnBeginShutdown(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnBeginShutdown\r\n     End Sub\r\n     ...<\/pre>\n
Listing 2: Code des COM-Add-Ins, Teil 1<\/span><\/b><\/p>\n
Ribbon erweitern<\/h2>\n
In unserem Fall wollen wir das COM-Add-In nur nutzen, um dem Ribbon von Access einige neue Elemente hinzuzufügen. Dazu implementieren wir die Funktion GetCustomUI <\/b>der Schnittstelle IRibbonUI<\/b>. Diese wird von Access aus aufgerufen und wir bekommen so die Gelegenheit, Access eine Anpassung des Ribbons zu übergeben. Wir tun das wie in Listing 3, wo wir die passende Ribbon-Definition in der Variablen strXML <\/b>zusammenstellen. Wer genau hinschaut, sieht, dass wir hier nicht strXML = strXML & … <\/b>verwenden, sondern dass wir hier einen anderen Operator verwenden, um die Zeilen zusammenzufügen, nämlich &=<\/b>.<\/p>\n
     Private <\/span>Function GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> Implements IRibbonExtensibility.GetCustomUI\r\n         Dim <\/span>strXML As String<\/span>\r\n         strXML &= \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\" \" _\r\n             & \"loadImage=\"\"LoadImage\"\" onLoad=\"\"onLoad\"\">\" & vbCrLf<\/span>\r\n         strXML &= \"  <ribbon startFromScratch=\"\"false\"\">\" & vbCrLf<\/span>\r\n         strXML &= \"    <tabs>\" & vbCrLf<\/span>\r\n         strXML &= \"      <tab idMso=\"\"TabHomeAccess\"\">\" & vbCrLf<\/span>\r\n         strXML &= \"        <group idMso=\"\"GroupFindAccess\"\" visible=\"\"false\"\" \/>\" & vbCrLf<\/span>\r\n         strXML &= \"        <group id=\"\"grpSuchenUndErsetzen\"\" insertAfterMso=\"\"GroupFindAccess\"\" \" _\r\n             & \"label=\"\"amvSuchenUndErsetzen\"\">\" & vbCrLf<\/span>\r\n         strXML &= \"          <button id=\"\"btnSuchen\"\" imageMso=\"\"FindDialog\"\" size=\"\"large\"\" \" _\r\n             & \"onAction=\"\"onAction\"\" label=\"\"Suchen\"\"\/>\" & vbCrLf<\/span>\r\n         strXML &= \"          <button id=\"\"btnErsetzen\"\" imageMso=\"\"ReplaceDialog\"\" size=\"\"normal\"\" \" _\r\n             & \"onAction=\"\"onAction\"\" label=\"\"Ersetzen\"\"\/>\" & vbCrLf<\/span>\r\n         strXML &= \"          <control idMso=\"\"GoToMenuAccess\"\" size=\"\"normal\"\" \/>\" & vbCrLf<\/span>\r\n         strXML &= \"          <control idMso=\"\"SelectMenuAccess\"\" size=\"\"normal\"\" \/>\" & vbCrLf<\/span>\r\n         strXML &= \"        <\/group>\" & vbCrLf<\/span>\r\n         strXML &= \"      <\/tab>\" & vbCrLf<\/span>\r\n         strXML &= \"    <\/tabs>\" & vbCrLf<\/span>\r\n         strXML &= \"  <\/ribbon>\" & vbCrLf<\/span>\r\n         strXML &= \"<\/customUI>\" & vbCrLf<\/span>\r\n         Return strXML\r\n     End Function\r\n     Function OnLoad(ribbon As <\/span>IRibbonUI)\r\n         Set<\/span> objRibbon = ribbon\r\n     End Function\r\n     Public <\/span>Sub OnAction(control As <\/span>IRibbonControl)\r\n         Select Case control.Id\r\n             Case <\/span>\"btnSuchen\"\r\n                 objAccess.Run Environ(\"AppData\") & \"\\Microsoft\\AddIns\\amvSuchenUndErsetzen.amvSuchen\"\r\n             Case <\/span>\"btnErsetzen\"\r\n                 objAccess.Run Environ(\"AppData\") & \"\\Microsoft\\AddIns\\amvSuchenUndErsetzen.amvErsetzen\"\r\n                 Case Else<\/span>\r\n                 MsgBox<\/span> \"OnAction nicht behandelt: \" & control.Id\r\n         End Select<\/span>\r\n     End Sub\r\nEnd Class<\/span><\/pre>\n
Listing 3: Code des COM-Add-Ins, Teil 2<\/span><\/b><\/p>\n
Was genau erledigen wir mit dieser Ribbondefinition? Wir definieren das customUI<\/b>-Element, das ribbon<\/b>-Element und das tabs<\/b>-Element wie in jeder herkömmlichen Ribbonerweiterung.<\/p>\n
Danach fügen wir ein tab<\/b>-Element mit dem Wert TabHomeAccess <\/b>für das Attribut idMso<\/b> hinzu. Damit referenzieren wir das Ribbontab mit der Beschriftung Start<\/b>.<\/p>\n
Darunter referenzieren wir ein group<\/b>-Element, das den Wert GroupFindAccess <\/b>für das Attribut idMso <\/b>enthält. Das entspricht dem eingebauten Bereich mit den Funktionen Suchen <\/b>und Ersetzen <\/b>(siehe Bild 7). Dieses wollen wir ausblenden und durch unsere eigene Version ersetzen, also stellen wir das Attribut visible <\/b>auf false <\/b>ein.<\/p>\n
\"Das<\/p>\n
Bild 7: Das zu ersetzende Ribbon-Element<\/span><\/b><\/p>\n
Danach legen wir unsere eigene Struktur für diesen Zweck an. Das erledigen wir mit einem benutzerdefinierten group<\/b>-Element mit der ID grpSuchenUndErsetzen <\/b>und der Beschriftung amvSuchenUndErsetzen<\/b>.<\/p>\n
Damit diese Gruppe an der gleichen Stelle angezeigt wird wie die zuvor ausgeblendete Gruppe, fügen wir diese über das Attribut insertAfterMso <\/b>genau dort ein – und zwar mit dem Wert GroupFindAccess<\/b>.<\/p>\n
Schließlich fügen wir zunächst zwei rein benutzerdefinierte button<\/b>-Elemente namens btnSuchen <\/b>und btnErsetzen <\/b>ein – samt entsprechenden Beschriftungen.<\/p>\n
Wie im Original soll die Suchen<\/b>-Schaltfläche groß dargestellt werden und die Ersetzen<\/b>-Schaltfläche klein. Damit die gleichen Icons wie beim Original erscheinen, stellen wir die Eigenschaft imageMso <\/b>jeweils auf die Namen dieser Elemente ein, nämlich FindDialog <\/b>und ReplaceDialog<\/b>.<\/p>\n
Danach replizieren wir noch die beiden übrigen Steuerelemente aus der Originalgruppe, indem wir button<\/b>-Elemente anlegen, deren Attribut idMso <\/b>wir mit den Werten GoToMenuAccess <\/b>und SelectMenuAccess <\/b>füllen.<\/p>\n
Danach fügen wir die fehlenden schließenden Elemente hinzu wie zum Beispiel <\/group><\/b>.<\/p>\n
Die Anweisung Return strXML <\/b>gibt die Zeichenkette aus strXML <\/b>als Funktionswert an Access zurück.<\/p>\n
Schließlich fehlen noch die Aktionen, die beim Anklicken der beiden benutzerdefinierten button<\/b>-Elemente ausgelöst werden sollen.<\/p>\n
Dazu nutzen wir die Prozedur OnAction<\/b>, die wir bereits für das gleichnamige Attribut der beiden button-Elemente hinterlegt haben (onAction=“onAction“<\/b>).<\/p>\n
Diese erhält nach dem Auslösen durch Betätigen einer der Schaltflächen mit dem Parameter control <\/b>einen Verweis auf das auslösende Element.<\/p>\n
Dieses liefert mit der Eigenschaft Id <\/b>den Namen des passenden button<\/b>-Elements, den wir in einer Select Case-Bedingung auswerten.<\/p>\n
Lautet dieser btnSuchen<\/b>, führen wir die folgende Anweisung aus:<\/p>\n
objAccess.Run Environ(\"AppData\") & \"\\Microsoft\\AddIns\\amvSuchenUndErsetzen.amvSuchen\"<\/pre>\n
Mit Environ(„AppData“) <\/b>holen wir den Pfad zum Benutzerverzeichnis, indem sich die Unterordner Microsoft <\/b>und AddIns <\/b>befinden. In diesen Ordner, der auch die übrigen Access-Add-Ins enthält, wollen wir auch die Access-Add-In-Datenbank amvSuchenUndErsetzen.accda <\/b>speichern.<\/p>\n
Damit daraus die Funktion amvSuchen <\/b>aufgerufen wird, fügen wir diese statt der Dateiendung .accda <\/b>an den Namen der Datenbankdatei an. Es ist wichtig, dass die Datenbankdatei die Dateiendung aufweist – anderenfalls findet Application.Run <\/b>diese so nicht.<\/p>\n
Zum Aufrufen der Funktion amvErsetzen <\/b>hängen wir entsprechend den Namen dieser Funktion an den Parameter der Anweisung Application.Run <\/b>an.<\/p>\n
Damit ist der Code für das COM-Add-In bereits vollständig. <\/p>\n
COM-Add-In erstellen und registrieren<\/h2>\n
Nun müssen wir nur noch die COM-Add-In-DLL erstellen und gleichzeitig registrieren. Beides erledigen wir von twinBASIC aus über den Befehl File|Build <\/b>(siehe Bild 8).<\/p>\n
\"Erstellen<\/p>\n
Bild 8: Erstellen und Registrieren des COM-Add-Ins<\/span><\/b><\/p>\n
Dadurch sollte im Bereich DEBUG CONSOLE<\/b> von twinBASIC die Ausgabe aus Bild 9 erscheinen. Hier sehen wir, dass die Datei amvSuchenUndErsetzen_win32.dll <\/b>erstellt und registriert wurde. Werden hier Fehler gemeldet, kann das verschiedene Ursachen haben.<\/p>\n
\"Ausgabe<\/p>\n
Bild 9: Ausgabe beim Erstellen und Registrieren des COM-Add-Ins<\/span><\/b><\/p>\n