{"id":55001092,"date":"2017-08-01T00:00:00","date_gmt":"2020-05-13T21:25:59","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1092"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"AccessAddIn_mit_VSTO","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/AccessAddIn_mit_VSTO\/","title":{"rendered":"Access-Add-In mit VSTO"},"content":{"rendered":"

\"\"<\/p>\n

Access-Add-Ins können Sie mit Access selbst erstellen oder aber auch mit Visual Studio, zum Beispiel in der kostenlosen Visual Studio 2015 Community Edition. Dieser Beitrag zeigt, wie Sie ein Access-Add-In mit Visual Studio erstellen und was dabei zu beachten ist. Dabei legen wir vor allem ein Augenmerk darauf, wie Sie dem Fehlen einer Vorlage zum Erstellen von Access-Add-Ins begegnen und ein Add-In für eine andere Office-Anwendung nutzen, um ein Access-Add-In zu programmieren.<\/b><\/p>\n

Voraussetzungen<\/h2>\n

Die erste Voraussetzung ist das Vorhandensein von Visual Studio Community Edition 2015<\/b>, welches Sie nach Eingabe des Namens als Suchbegriff bei Google schnell finden sollten. Dieses kommt aber in der Regel nicht direkt mit den Office Developer Tools. Diese finden Sie ebenfalls am besten, wenn Sie bei Google die Suchbegriffe Office Developer Tools eingeben. Ein guter Startpunkt ist zum Zeitpunkt der Veröffentlichung dieses Beitrags aber auch diese Adresse:<\/p>\n

https:\/\/blogs.msdn.microsoft.com\/visualstudio\/2015\/11\/23\/latest-microsoft-office-developer-tools-for-visual-studio-2015\/<\/pre>\n
Sie müssen also zuerst Visual Studio 2015 Community Edition installieren und dann die aktuellsten Erweiterungen herunterladen. Danach sollten Sie, wenn Sie Visual Studio starten und ein neues Projekt anlegen, die Vorlagen wie in Bild 1 finden.<\/p>\n
\"Keine<\/p>\n
Bild 1: Keine Vorlage für ein Access-Add-In<\/span><\/b><\/p>\n
Add-In für Access<\/h2>\n
Wer weiß, dass die Elemente in alphabetischer Reihenfolge aufgelistet werden, und sieht, dass Excel 2013 und 2016 VSTO-Add-In <\/b>der erste Eintrag ist, erkennt schnell: Es gibt keine Vorlage für Add-Ins, die mit Access arbeiten. Aber das ist kein Problem: Wir starten einfach mit einem anderen Add-In-Typ, beispielsweise für Microsoft Excel, und passen das daraus generierte Projekt dann für den Einsatz in Access an.<\/p>\n
Start mit Excel statt mit Access<\/h2>\n
Sie erstellen also zunächst ein neues Projekt auf Basis der Vorlage Visual C# <\/b>(oder Visual Basic<\/b>)|Office\/SharePoint|VSTO-Add-Ins|Excel 2013 und 2016 VSTO-Add-In<\/b>. Geben Sie dabei den Projektnamen an, in unserem Beispiel schlicht AccessAddIn<\/b>.<\/p>\n
Nach einem Klick auf OK<\/b> erstellt Visual Studio das Projekt.<\/p>\n
Add-In in Excel testen<\/h2>\n
Wir wollen das Add-In, das wir ja nun erstellt, aber noch nicht für den Einsatz in Access angepasst haben, zunächst einmal auf seine Tauglichkeit unter Excel testen. Dazu klicken Sie in Visual Studio einfach auf F5 <\/b>und führen das Add-In so aus. Das Resultat ist ernüchternd, denn wir erhalten direkt eine Fehlermeldung wie in Bild 2.<\/p>\n
\"Fehler<\/p>\n
Bild 2: Fehler beim Start des Excel-Add-Ins<\/span><\/b><\/p>\n
Um dieses erste Problem zu beheben, schließen Sie Excel und öffnen es das nächste Mal als Administrator. Dazu geben Sie Excel in das Suchen-Feld von Windows ein, klicken mit der rechten Maustaste auf den Eintrag Excel 2016 <\/b>und wählen aus dem Kontextmenü den Eintrag Als Administrator ausführen <\/b>aus (s. Bild 3).<\/p>\n
\"Excel<\/p>\n
Bild 3: Excel als Administrator starten<\/span><\/b><\/p>\n
Nach dem öffnen von Excel und dem Erstellen oder Laden einer Datei öffnen Sie über den Backstage-Bereich die Excel-Optionen und wechseln dort zum Bereich Menüband anpassen<\/b>. Hier aktivieren Sie nun die Hauptregisterkarte Entwicklertools <\/b>(s. Bild 4).<\/p>\n
\"Entwicklertools<\/p>\n
Bild 4: Entwicklertools aktivieren<\/span><\/b><\/p>\n
Dies fügt dem Ribbon von Excel einen neuen Reiter namens Entwicklertools hinzu. In diesem finden Sie eine Schaltfläche namens COM-Add-Ins<\/b>. Wenn Sie diese anklicken, öffnet sich die Liste der aktuell aktiverten Add-Ins. Ganz oben sehen Sie bereits den Eintrag Access-AddIn <\/b>für unser soeben erstelltes Add-In. Ganz unten sollten Sie den Eintrag Visual Studio Tools for Office Design-Time Adaptor for Excel<\/b> sehen. Diesen Eintrag müssen Sie deaktivieren, um den Fehler beim Aufruf von GetCustomUI() <\/b>zu beheben (s. Bild 5).<\/p>\n
\"Fehler<\/p>\n
Bild 5: Fehler durch GetCustomUI beheben<\/span><\/b><\/p>\n
Bevor wir uns nun an die Arbeit machen, das Add-In für den Einsatz mit Access umzurüsten, wollen wir zumindest noch eine Ribbon-Schaltfläche hinzufügen, welche ein Meldungsfenster anzeigt. Damit stellen wir sicher, dass das Add-In grundsätzlich funktioniert. Es wäre schade, wenn wir nun erst die ganzen Schritte für die Anpassung als Access-Add-In durchführen und dann, wenn es nicht funktionieren sollte, nicht wissen, wo der Fehler zu suchen ist.<\/p>\n
Sobald Sie Excel nun schließen und erneut starten, erscheint die Fehlermeldung nicht mehr.<\/p>\n
Ribbon hinzufügen<\/h2>\n
Nun wollen wir den Code zur Erstellung eines Ribbons zu unserem Add-In hinzufügen. Dazu erstellen Sie in Visual Studio eine neue Klasse, indem Sie den Kontextmenü-Eintrag des Projekts AccessAddIn <\/b>aus dem Projektmappen-Explorer namens Hinzufügen|Neues Element… <\/b>anklicken. Es erscheint der Dialog aus Bild 6, mit dem Sie ein Element des Typs Menüband (Visueller Designer) <\/b>namens AddInRibbon.cs <\/b>hinzufügen.<\/p>\n
\"Hinzufügen<\/p>\n
Bild 6: Hinzufügen eines Ribbons<\/span><\/b><\/p>\n
Es erscheint die Ansicht aus Bild 7, mit der Sie die Ribbon-Steuerelemente aus der Toolbox an die gewünschten Stellen im Ribbon einfügen können. Nun bedarf es einiger Erläuterungen, was es mit dem Element TabAddIns (Integriert) <\/b>auf sich hat. Eines steht jedoch fest: Durch das einfache Hinzufügen eines Ribbons ändert sich noch nichts, beim nächsten Debuggen\/Starten des Add-Ins per F5 <\/b>öffnet sich zwar Excel, aber es erscheinen keine zusätzlichen Elemente im Ribbon.<\/p>\n
\"Bearbeiten<\/p>\n
Bild 7: Bearbeiten des Ribbbons<\/span><\/b><\/p>\n
Schaltfläche zum Ribbon hinzufügen<\/h2>\n
Wir fügen nun zunächst eine Schaltfläche zum Ribbon hinzu, indem wir ein Button<\/b>-Element aus der Toolbox in den Bereich group1 <\/b>ziehen. Die Beschriftung beider Elemente, also der Gruppe und der Schaltfläche, passen wir nun an.<\/p>\n
Dazu klicken Sie auf das Element, in Bild 8 zum Beispiel auf das Button<\/b>-Element, und stellen im Eigenschaften-Bereich die Eigenschaft Label <\/b>auf den gewünschten Wert ein, in diesem Fall Test<\/b>. Im gleichen Zug können Sie die Eigenschaft Name <\/b>auf den Wert btnTest <\/b>ändern. Für das Group<\/b>-Element stellen Sie Label <\/b>auf Beispielgruppe <\/b>und Name <\/b>auf grpBeispiel <\/b>ein.<\/p>\n
\"Bezeichnung<\/p>\n
Bild 8: Bezeichnung der Schaltfläche ändern<\/span><\/b><\/p>\n
Nun fügen wir noch eine Ereignisprozedur zur Schaltfläche hinzu. Das Klassenmodul mit dem Code für das Ribbon-Objekt öffnen Sie, indem Sie aus dem Kontextmenü der Schaltfläche den Eintrag Code anzeigen <\/b>auswählen (s. Bild 9). Dieser enthält jedoch noch keine Ereignisprozedur für die Schaltfläche btnTest<\/b>. Diese legen Sie am einfachsten an, indem Sie in der Entwurfsansicht doppelt auf die Schaltfläche klicken.<\/p>\n
\"Anzeigen<\/p>\n
Bild 9: Anzeigen der Ereignisprozedur der Schaltfläche<\/span><\/b><\/p>\n
Sollte nun nicht automatisch die Klasse hinter dem Ribbon-Element erscheinen, können Sie diese wiederum über den Kontextmenü-Befehl Code anzeigen <\/b>oder die Taste F7 <\/b>öffnen. Dieses Klassenmodul enthält nun eine Methode namens btnText_Click<\/b>. Wir wollen dieser ein einfaches Meldungsfenster hinzufügen, wozu zwei Schritte nötig sind. Als Erstes fügen Sie der Klasse oben mit der using<\/b>-Anweisung einen Verweis auf das Namespace System.Windows.Forms <\/b>hinzu:<\/p>\n
using System.Windows.Forms;<\/pre>\n
Die C#-Methode füllen wir dann mit einem einfachen Aufruf der Show<\/b>-Methode der MessageBox<\/b>-Klasse (s. Bild 10):<\/p>\n
\"Hinzufügen<\/p>\n
Bild 10: Hinzufügen einer MessageBox zur Schaltfläche<\/span><\/b><\/p>\n
private void btnTest_Click(object sender,  RibbonControlEventArgs e) {\r\n     MessageBox.Show(\"Schaltfläche  angeklickt.\");\r\n}<\/pre>\n
Wenn Sie nun das Add-In per F5 <\/b>starten\/debuggen, wird Excel geöffnet, aber auf den ersten Blick ist kein neuer Eintrag zu erkennen. Dieser erscheint erst, wenn Sie nun auf den Tab Add-Ins <\/b>klicken. Dort finden Sie dann neben der Gruppe Benutzerdefinierte Symbolleisten <\/b>unsere selbst definierte Gruppe namens Beispielgruppe <\/b>und die Schaltfläche Test<\/b>. Klicken Sie diese an, taucht auch prompt die von uns programmierte Meldung auf (s. Bild 11).<\/p>\n
\"Die<\/p>\n
Bild 11: Die neu hinzugefügte Add-In-Schaltlfäche<\/span><\/b><\/p>\n
Wechsel zu Access<\/h2>\n
Nun gehen wir einen Schritt weiter und wollen das Add-In so anpassen, dass es nicht unter Excel, sondern unter Access geöffnet wird. Dazu sind einige änderungen nötig, die wir teilweise im Text-Editor Ihrer Wahl durchführen müssen, weil die entsprechenden Dateien nicht in Visual Studio geöffnet werden können.<\/p>\n
Schritt 1: Verweis auf die Access-Bibliothek<\/h2>\n
<\/p>\n
Die erste änderung ist das Hinzufügen eines Verweises auf die Access-Bibliothek. Dazu betätigen Sie den Menübefehl Projekt|Verweis hinzufügen…<\/b>, der den Verweis-Manager <\/b>öffnet. Aus unerfindlichen Gründen finden Sie den Verweis auf die Bibliothek Microsoft Access x.0 Object Library <\/b>nicht wie gewohnt im Bereich COM\/Typbibliotheken <\/b>(s. Bild 12).<\/p>\n
\"Der<\/p>\n
Bild 12: Der Verweis auf Microsoft Access 16.0 Object Library fehlt.<\/span><\/b><\/p>\n
Stattdessen müssen Sie auf den Bereich Durchsuchen <\/b>wechseln und dort auf die Schaltfläche Durchsuchen… <\/b>klicken. Hier navigieren Sie zur Datei MSACC.OLB<\/b>, die sich unter Office 2016 beispielsweise in diesem Verzeichnis befindet: C:\\Program Files (x86)\\Microsoft Office\\root\\Office16<\/b>. Nachdem Sie diese ausgewählt haben, sieht der Dialog Verweis-Manager <\/b>wie in Bild 13 aus.<\/p>\n
\"Hinzufügen<\/p>\n
Bild 13: Hinzufügen per Durchsuchen…<\/span><\/b><\/p>\n
Datei ThisAddIn.Designer.cs ändern<\/h2>\n
Eine wichtige Rolle spielt die Datei ThisAddIn.Designer.cs<\/b>. Sie legt unter anderem fest, welche Anwendung als Host verwendet wird. Damit es sich dabei nicht mehr um Excel handelt, sondern um Access, sind einige änderungen nötig. Die Datei finden Sie nicht direkt im Projektmappen-Explorer, sondern Sie müssen diese über den Windows Explorer per Doppelklick öffnen oder diese einfach aus dem Windows Explorer in Visual Studio ziehen. Wir schauen uns die notwendigen änderungen von oben nach unten an. Die vorherige Version der Anweisungen haben wir jeweils auskommentiert (dies geschieht unter C# durch Voranstellen zweier Schrägstriche). Als Erstes ändern wir folgende Zeile, wobei einfach Excel <\/b>durch Access <\/b>ersetzt wird (ca. Zeile 28):<\/p>\n
\/\/internal Microsoft.Office.Interop.Excel.Application Application;\r\ninternal Microsoft.Office.Interop.Access.Application Application;<\/pre>\n
Die zweite änderung folgt gleich ein paar Zeilen weiter unten. Hier wird Excel.ApplicationFactory <\/b>einfach durch das allgemeine Factory<\/b>-Objekt ersetzt (für Access gibt es kein ApplicationFactory<\/b>-Objekt, ca. Zeile 33):<\/p>\n
\/\/public ThisAddIn(global::Microsoft.Office.Tools.Excel.ApplicationFactory factory, global::System.IServiceProvider serviceProvider) : base(factory, serviceProvider, \"AddIn\", \"ThisAddIn\") {\r\npublic ThisAddIn(global::Microsoft.Office.Tools.Factory factory, global::System.IServiceProvider serviceProvider) : base(factory, serviceProvider, \"AddIn\", \"ThisAddIn\") {<\/pre>\n
In der Methode Initialize<\/b> ersetzen wir wie folgt Excel <\/b>durch Access<\/b> (ca. Zeile 43):<\/p>\n
\/\/this.Application = this.GetHostItem<Microsoft.Office.Interop.Excel.Application>(typeof(Microsoft.Office.Interop.Excel.Application), \"Application\");\r\nthis.Application = this.GetHostItem<Microsoft.Office.Interop.Access.Application>(typeof(Microsoft.Office.Interop.Access.Application), \"Application\");<\/pre>\n
Und es folgen noch zwei Ersetzungen der Factory. Die erste sieht so aus (ca. Zeile 184):<\/p>\n
\/\/private static global::Microsoft.Office.Tools.Excel.ApplicationFactory _factory;\r\nprivate static global::Microsoft.Office.Tools.Factory _factory;<\/pre>\n
Die zweite betrifft diese Zeile (ca. Zeile 202):<\/p>\n
\/\/internal static global::Microsoft.Office.Tools.Excel.ApplicationFactory Factory {\r\ninternal static global::Microsoft.Office.Tools.Factory Factory {<\/pre>\n
Anweisungen in ThisAddIn.Designer.cs löschen<\/h2>\n
Nun entfernen wir einige Anweisungen aus der gleichen Datei, welche die ordnungsgemäße Ausführung des Add-Ins in Access verhindern. Damit Sie sich ungefähr an den Zeilennummern orientieren, kommentieren Sie die betroffenen Zeilen einfach durch Voranstellen von \/\/ aus. Die ersten beiden Zeilen finden Sie ab Zeile 20:<\/p>\n
\/\/ internal Microsoft.Office.Tools.CustomTaskPaneCollection CustomTaskPanes;\r\n\/\/ internal Microsoft.Office.Tools.SmartTagCollection VstoSmartTags;<\/pre>\n
Zeile 126:<\/p>\n
\/\/this.CustomTaskPanes.BeginInit();\r\n\/\/this.VstoSmartTags.BeginInit();<\/pre>\n
Zeile 134:<\/p>\n
\/\/this.VstoSmartTags.EndInit();\r\n\/\/this.CustomTaskPanes.EndInit();<\/pre>\n
Zeile 144:<\/p>\n
\/\/this.CustomTaskPanes = Globals.Factory.CreateCustomTaskPaneCollection(null, null, \"CustomTaskPanes\", \"CustomTaskPanes\", this);\r\n\/\/this.VstoSmartTags = Globals.Factory.CreateSmartTagCollection(null, null, \"VstoSmartTags\", \"VstoSmartTags\", this);<\/pre>\n
Zeile 163:<\/p>\n
\/\/[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]\r\n\/\/[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"Microsoft.VisualStudio.Tools.Office.ProgrammingModel.dll\", \"14.0.0.0\")]\r\n\/\/[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never)]\r\n\/\/protected override void OnShutdown() {\r\n\/\/    this.VstoSmartTags.Dispose();\r\n\/\/    this.CustomTaskPanes.Dispose();\r\n\/\/    base.OnShutdown();\r\n\/\/}<\/pre>\n
Damit sind die änderungen an dieser Datei abgeschlossen und Sie können diese speichern und schließen.<\/p>\n
ändern der Datei AccessAddIn.csproj<\/h2>\n
Nun kümmern wir uns um die .csproj<\/b>-Datei. Diese öffnen wir der Einfachheit halber mit einem externen Text-Editor. Hier nehmen wir unter anderem Einstellungen vor, die dafür sorgen, dass beim Starten des Debuggens die richtigen Einträge in der Registry landen.<\/p>\n
Bei dieser Datei handelt es sich um eine XML-Datei. Das heißt, dass wir Zeilen durch Voranstellen von  <\/b>auskommentieren. Die erste änderung findet in Zeile 54 statt:<\/p>\n
<!--<OfficeApplication>Excel<\/OfficeApplication>--> <OfficeApplication>Access<\/OfficeApplication><\/pre>\n
Die nächste änderung führen Sie etwa in Zeile 265 aus:<\/p>\n
<!--<ProjectProperties HostName=\"Excel\" HostPackage=\"{29A7B9D7-A7F1-4328-8EF0-6B2D1A56B2C1}\" OfficeVersion=\"15.0\" VstxVersion=\"4.0\" ApplicationType=\"Excel\" Language=\"cs\" TemplatesPath=\"\" DebugInfoExeName=\"#Software\\Microsoft\\Office\\16.0\\Excel\\InstallRoot\\Path#Excel.exe\" DebugInfoCommandLine=\"\/x\" AddItemTemplatesGuid=\"{51063C3A-E220-4D12-8922-BDA915ACD783}\" \/>--><\/pre>\n
Hier ändern wir alle Vorkommen von Excel <\/b>nach Access <\/b>(an zwei Stellen). Außerdem geben Sie als auszuführende Datei MSAccess.exe <\/b>statt Excel.exe <\/b>an und ändern in der Verzeichnisangabe …\\Excel\\… <\/b>in …\\Access\\…<\/b> (insgesamt also vier änderungen). Gegebenenfalls müssen Sie auch noch die Version anpassen, hier auf 16.0 <\/b>für Access 2016 (für das Attribut OfficeVersion <\/b>und im Pfad zur auszuführenden Datei):<\/p>\n
<ProjectProperties HostName=\"Access\" HostPackage=\"{29A7B9D7-A7F1-4328-8EF0-6B2D1A56B2C1}\" OfficeVersion=\"16.0\" VstxVersion=\"4.0\" ApplicationType=\"Access\" Language=\"cs\" TemplatesPath=\"\" DebugInfoExeName=\"#Software\\Microsoft\\Office\\16.0\\Access\\InstallRoot\\Path#msaccess.exe\" DebugInfoCommandLine=\"\/x\" AddItemTemplatesGuid=\"{51063C3A-E220-4D12-8922-BDA915ACD783}\" \/><\/pre>\n
Sie könnten diese Angabe auch in den Properties des Objekts im Bereich Debuggen <\/b>für die Eigenschaft Externes Programm starten: <\/b>einstellen. Die letzte änderung betrifft die folgende Zeile (etwa 266). Hier ersetzen Sie wieder einfach Excel <\/b>durch Access<\/b>:<\/p>\n
<!--<Host Name=\"Excel\" GeneratedCodeNamespace=\"AccessAddIn\" IconIndex=\"0\">-->\r\n<Host Name=\"Access\" GeneratedCodeNamespace=\"AccessAddIn\" IconIndex=\"0\"><\/pre>\n
Damit haben wir alle notwendigen änderungen durchgeführt und können die Anwendung erneut starten.<\/p>\n
Versuch des Starts<\/h2>\n
Wenn wir nun das Add-In mit F5 <\/b>debuggen\/starten, wird zwar Access geöffnet, aber unser Ribbon-Eintrag erscheint nicht. Das ist auch kein Wunder: Unter Access gibt es schließlich auch gar kein Tab-Element namens Add-Ins<\/b>. Um zu prüfen, ob unser Add-In überhaupt aufgerufen wird,  fügen wir nun erst einmal die Ausgabe einer Meldung beim Starten des Add-Ins hinzu.<\/p>\n
Dies erledigen Sie in Visual Studio, indem Sie das Modul ThisAddIn.cs <\/b>öffnen und die dort bereits vorhandene Ereignismethode ThisAddIn_Startup <\/b>wie folgt ergänzen:<\/p>\n
private void ThisAddIn_Startup(object sender, System.EventArgs e)\r\n{\r\n     MessageBox.Show(\"Startup\");\r\n}<\/pre>\n
Dies sollte beim nächsten Starten des Add-Ins von Visual Studio aus per F5<\/b> dazu führen, dass die Meldung beim Start von Access angezeigt wird.<\/p>\n
Mögliche Fehler<\/h2>\n
Wir schauen uns noch an, welche Fehler beim Starten des Add-ins auftreten könnten und kümmern uns dann um die Anpassung des Ribbons.<\/p>\n
Den Fehler mit der Fehlermeldung aus Bild 14 kennen wir beispielsweise sehr gut, weil wir ihn eine Weile immer wieder gesehen haben, bis wir die richtige Kombination der Anpassungen des Excel-Add-Ins an Access gefunden haben. Tritt dieser Fehler bei Ihnen auf, haben Sie schlicht nicht alle der aufgeführten änderungen durchgeführt.<\/p>\n
\"Fehler<\/p>\n
Bild 14: Fehler beim öffnen des Add-Ins<\/span><\/b><\/p>\n
Das Gleiche ist der Fall, wenn Access nach dem Starten des Add-Ins einfach abstürzt. Kontrollieren Sie dann noch einmal die Schritte und vergleichen sie gegebenenfalls mit dem Beispielprojekt. Wenn gar nichts geschieht, also auch nicht die weiter oben eingebaute Meldung erscheint, ist das Add-In möglicherweise nicht korrekt registriert. <\/p>\n
Dies können Sie prüfen, indem Sie die Windows Registry öffnen, und zwar, indem Sie im Suchen-Fenster von Windows den Ausdruck RegEdit <\/b>eingeben und die dann angezeigte App öffnen. Hier navigieren Sie dann zum folgenden Element (s. Bild 15):<\/p>\n
\"Das<\/p>\n
Bild 15: Das Add-In in der Windows-Registry<\/span><\/b><\/p>\n
HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\AccessAddIn<\/pre>\n
Liegt dort kein Eintrag wie in der Abbildung vor, kontrollieren Sie nochmals die durchgeführten Schritte.<\/p>\n
Gegebenenfalls ist der Eintrag fast mit dem hier abgebildeten identisch – es kann nämlich sein, dass der Wert des Schlüssels LoadBehaviour <\/b>auf 2 <\/b>eingestellt ist. Dies wird automatisch von Access erledigt, wenn beim Laden eines Add-Ins ein Fehler auftritt. Durch die änderung auf diesen Wert wird das Add-In beim nächsten Start von Access nicht mehr berücksichtigt. Sie müssen den Wert dann manuell wieder auf 3 <\/b>einstellen. Vielleicht wollen Sie den Eintrag auch komplett neu erstellen – dann entfernen Sie den Eintrag mit der entsprechenden Bezeichnung (hier AccessAddIn<\/b>) einfach und starten das Add-In von Visual Studio aus neu.<\/p>\n
Ribbon an Access anpassen<\/h2>\n
Nun wollen wir uns um die Anzeige eines Ribbon-Eintrags für das Add-In kümmern. Dies ist die gängigste Weise, um ein Add-In von Access aus zu starten. Grundsätzlich haben wir zwei Möglichkeiten:<\/p>\n