{"id":55000504,"date":"2026-04-01T00:00:00","date_gmt":"2026-03-10T13:53:06","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=504"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"SQL_ServerVerbindungen_per_Backstage_verwalten","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/SQL_ServerVerbindungen_per_Backstage_verwalten\/","title":{"rendered":"SQL Server-Verbindungen per Backstage verwalten"},"content":{"rendered":"

Wer in Access mit verknüpften SQL Server-Tabellen arbeitet, kennt das Problem: Die Verbindungszeichenfolge muss korrekt zusammengesetzt sein, Treiber und Authentifizierungsart müssen stimmen – und bei jeder neuen Datenbank fängt man von vorn an. Dieser Artikel zeigt, wie Du einen eigenen Tab im Backstage-Bereich von Access einrichtest, der Dir das Zusammenbauen der Verbindungszeichenfolge abnimmt. <\/b><\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispieldatenbank zum Artikel enthält die Tabelle USysRibbons<\/b> mit dem XML für den Backstage-Tab sowie das Modul mdlBackstage<\/b> mit allen Callback-Prozeduren. Du kannst die Datenbank direkt öffnen und den Backstage-Tab sofort verwenden – oder den Code als Vorlage für Deine eigene Datenbank nutzen.<\/p>\n

Was der Backstage-Tab leistet<\/h2>\n

Der Tab SQL Server-Verbindung<\/b> erscheint im Backstage-Bereich von Access – also in dem Bereich, der sich öffnet, wenn Du auf Datei<\/b> klickst (siehe Bild 1). Er enthält auf der linken Seite alles, was zum manuellen Aufbau einer Verbindungszeichenfolge nötig ist:<\/p>\n

\"Der<\/p>\n

Bild 1: Der Backstage-Tab SQL Server-Verbindung in Access<\/span><\/b><\/p>\n

    \n
  • Treiber-Auswahl:<\/b> Ein Dropdown mit den drei gängigsten ODBC-Treibern für SQL Server – ODBC Driver 17 for SQL Server<\/b>, ODBC Driver 18 for SQL Server<\/b> und SQL Server Native Client 11.0<\/b>.<\/li>\n
  • Servername mit History:<\/b> Eine ComboBox, die sowohl freie Eingabe als auch die Auswahl aus zuvor verwendeten Servernamen erlaubt. Neue Servernamen werden automatisch gespeichert. Ein Löschen<\/b>-Button entfernt den aktuell eingetragenen Namen aus der History.<\/li>\n
  • Datenbanken laden:<\/b> Ein Button verbindet sich mit dem eingetragenen Server und liest alle verfügbaren Datenbanken aus. Das Ergebnis erscheint als Auswahlliste in der Datenbankname-ComboBox.<\/li>\n
  • Authentifizierung:<\/b> Eine RadioGroup<\/b> schaltet zwischen Windows-Authentifizierung und SQL Server-Authentifizierung um. Bei SQL Server-Authentifizierung werden die Felder für Benutzername und Kennwort automatisch aktiviert.<\/li>\n
  • Verbindungszeichenfolge:<\/b> Das Ergebnis aller Eingaben wird in Echtzeit als fertige Verbindungszeichenfolge angezeigt. Zwei Buttons ermöglichen das Testen der Verbindung und das Kopieren in die Zwischenablage.<\/li>\n<\/ul>\n

    So verwendest Du den Backstage-Tab<\/h2>\n

    Nach dem Einrichten des Tabs – wie das geht, beschreibt der nächste Abschnitt – öffnest Du ihn über Datei|SQL Server-Verbindung<\/b>. Beim ersten Aufruf sind alle Felder leer.<\/p>\n

      \n
    • Schritt 1 – Treiber wählen:<\/b> Wähle im Dropdown ODBC-Treiber<\/b> den auf Deinem System installierten Treiber aus. Meist ist das ODBC Driver 17 for SQL Server<\/b>. Der ODBC Driver 18 <\/b>erfordert zusätzliche Parameter für die verschlüsselte Verbindung, die automatisch ergänzt werden. Falls Du noch den älteren Native Client <\/b>im Einsatz hast, steht auch SQL Server Native Client 11.0<\/b> zur Verfügung (siehe Bild 2).<\/li>\n

      \"Treiber-Auswahl<\/p>\n

      Bild 2: Treiber-Auswahl im Dropdown<\/span><\/b><\/p>\n

    • Schritt 2 – Servername eingeben:<\/b> Trage den Servernamen in die ComboBox Servername<\/b> ein. Das kann ein Rechnername, eine IP-Adresse oder ein benannter Instanzname im Format Rechnername\\Instanzname<\/b> sein. Sobald Du den Namen bestätigst, wird er automatisch in der History gespeichert und beim nächsten Mal in der Auswahlliste angeboten (siehe Bild 3). Nicht mehr benötigte Einträge entfernst Du über den Löschen<\/b>-Button rechts neben der ComboBox – nach einer Rückfrage wird der aktuell angezeigte Name aus der Liste entfernt.<\/li>\n

      \"Servername-ComboBox<\/p>\n

      Bild 3: Servername-ComboBox mit History-Einträgen<\/span><\/b><\/p>\n

    • Schritt 3 – Authentifizierung festlegen:<\/b> Wähle zwischen Windows-Authentifizierung<\/b> und SQL Server-Authentifizierung<\/b>. Bei Windows-Authentifizierung werden die Felder für Benutzername und Kennwort deaktiviert – die Anmeldedaten des aktuellen Windows-Benutzers werden automatisch verwendet. Bei SQL Server-Authentifizierung werden beide Felder aktiv und müssen ausgefüllt werden (siehe Bild 4).<\/li>\n

      \"Authentifizierungsoptionen\"<\/p>\n

      Bild 4: Authentifizierungsoptionen<\/span><\/b><\/p>\n

    • Schritt 4 – Datenbanken laden:<\/b> Klicke auf Datenbanken mit aktuellen Zugangsdaten laden<\/b>. Das Add-In baut eine Verbindung zum Server auf – ohne Datenbankangabe – und liest alle verfügbaren Datenbanken aus. Das kann je nach Netzwerk und Server einige Sekunden dauern. Die gefundenen Datenbanken erscheinen anschließend in der ComboBox Datenbankname<\/b> (siehe Bild 5). Du kannst den Datenbanknamen alternativ auch direkt eingeben, falls Du ihn kennst.<\/li>\n

      \"Datenbankname-ComboBox<\/p>\n

      Bild 5: Datenbankname-ComboBox nach dem Laden der verfügbaren Datenbanken<\/span><\/b><\/p>\n

    • Schritt 5 – Verbindungszeichenfolge prüfen und testen:<\/b> Die fertig zusammengesetzte Verbindungszeichenfolge erscheint im unteren Bereich der linken Spalte. Sie wird nach jeder Änderung automatisch aktualisiert und zeilenweise dargestellt, damit sie gut lesbar ist (siehe Bild 6). Über Verbindung testen<\/b> prüfst Du, ob die Verbindung tatsächlich aufgebaut werden kann. Bei Erfolg erscheint eine kurze Bestätigungsmeldung, bei einem Fehler die Fehlerbeschreibung von ADODB – das hilft beim schnellen Eingrenzen von Problemen wie falschem Kennwort, nicht erreichbarem Server oder fehlendem Treiber.<\/li>\n

      \"Fertige<\/p>\n

      Bild 6: Fertige Verbindungszeichenfolge mit zeilenweiser Darstellung<\/span><\/b><\/p>\n<\/ul>\n

      Mit In Zwischenablage kopieren<\/b> übernimmst Du die Zeichenfolge in einem Schritt – ohne die Darstellung im Label manuell markieren zu müssen. Von dort aus kannst Du sie zum Beispiel direkt in den VBA-Editor einfügen oder in eine andere Anwendung übertragen.<\/p>\n

      Einrichtung in der Datenbank<\/h2>\n

      Der Backstage-Tab wird über die Systemtabelle USysRibbons<\/b> in der jeweiligen Access-Datenbank eingerichtet. Die Tabelle muss einmalig angelegt werden – die Beispieldatenbank zum Artikel enthält sie bereits. Sie besteht aus drei Feldern: ID<\/b> (Primärschlüsselfeld mit Autowert), Ribbon RibbonName<\/b> (Text) und RibbonXml<\/b> (Memo). In RibbonXml<\/b> steht das vollständige XML, das den Tab beschreibt. In den Access-Optionen unter Aktuelle Datenbank<\/b> trägst Du im Feld Name des Menübands <\/b>den Wert aus RibbonName<\/b> ein. Nach dem nächsten Öffnen der Datenbank ist der Tab aktiv.<\/p>\n

      Die Callback-Prozeduren befinden sich im Modul mdlBackstage<\/b>. Die Verbindungseinstellungen werden in der Windows-Registry unter dem Schlüssel HKCU\\Software\\VB and VBA Program Settings\\amvSQLServerConnection\\SQLServer<\/b> gespeichert. Das hat den Vorteil, dass die Einstellungen datenbankübergreifend gelten – Du musst Servernamen und Zugangsdaten nicht in jeder Datenbank neu eingeben.<\/p>\n

      Die Servernamen-History wird unter dem Registry-Wert Servernamen<\/b> als pipe-separierte Liste gespeichert, zum Beispiel:<\/p>\n

      194.163.171.28|SQLSERVER01|LAPTOP\\SQLEXPRESS<\/pre>\n
      XML-Definition für den Backstage-Bereich<\/h2>\n
      Das XML beginnt mit dem üblichen customUI<\/b>-Wurzelelement, gefolgt von <\/b> und einem <\/b>-Element mit einer eigenen ID. Das Attribut insertAfterMso=”TabInfo”<\/b> sorgt dafür, dass der Tab hinter dem Informationen<\/b>-Tab erscheint. Das Attribut title<\/b> legt die Überschrift fest, die im Backstage über dem Inhalt angezeigt wird:<\/p>\n
      <customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\r\n    onLoad=\"customUI_OnLoad\">\r\n  <backstage>\r\n    <tab id=\"tabSQLServer\"\r\n         label=\"SQL Server-Verbindung\"\r\n         insertAfterMso=\"TabInfo\"\r\n         title=\"SQL Server-Verbindungszeichenfolgen\">\r\n      <firstColumn>\r\n        ...\r\n      <\/firstColumn>\r\n    <\/tab>\r\n  <\/backstage>\r\n<\/customUI><\/pre>\n
      Das Attribut onLoad<\/b> verweist auf eine Callback-Funktion, die beim Laden des Ribbons aufgerufen wird und eine Referenz auf das IRibbonUI<\/b>-Objekt liefert. Diese Referenz wird in einer Modulvariablen gespeichert und später benötigt, um das Backstage nach Änderungen neu zu zeichnen:<\/p>\n
      Private <\/span>m_ribbon As <\/span>IRibbonUI\r\nPublic Function <\/span>customUI_OnLoad(ribbon As <\/span>IRibbonUI) _\r\n        As <\/span>IRibbonUI\r\n    Set<\/span> m_ribbon = ribbon\r\n    Call<\/span> ServernamenLaden\r\n    Call<\/span> DatenbanknamenLeeren\r\nEnd Function<\/span><\/pre>\n
      Alle Callback-Prozeduren kommen in ein Standardmodul namens mdlBackstage<\/b>. Für die Registry-Speicherung verwendet die Lösung zwei Konstanten:<\/p>\n
      Public <\/span>Const cStrAppName As String<\/span> = _\r\n    \"amvSQLServerConnection\"\r\nPublic <\/span>Const cStrSection As String<\/span> = _\r\n    \"SQLServer\"<\/pre>\n
      Die Registry eignet sich hier gut als Speicherort, weil die Verbindungsdaten datenbankübergreifend verfügbar sein sollen – einmal konfiguriert, stehen sie in jeder Datenbank zur Verfügung, die diesen Backstage-Tab verwendet.<\/p>\n
      Klassen wie IRibbonUI <\/b>sind in der Bibliothek Microsoft Office 16.0 Object Library <\/b>definiert, daher müssen wir noch einen Verweis auf diese Bibliothek zu den Verweisen des VBA-Projekts hinzufügen.<\/p>\n
      Steuerelemente im Backstage-Tab<\/h2>\n
      Der Tab verwendet eine einzelne Spalte (firstColumn<\/b>), die in mehrere Gruppen unterteilt ist. Jede Gruppe enthält ein topItems<\/b>-Element, das die eigentlichen Steuerelemente aufnimmt. Im Backstage stehen nicht alle Steuerelemente des Ribbons zur Verfügung – die wichtigsten für diese Lösung sind dropDown<\/b>, comboBox<\/b>, editBox<\/b>, radioGroup<\/b>, labelControl<\/b>, button<\/b> und layoutContainer<\/b>.<\/p>\n
      Ein wesentlicher Unterschied zum Ribbon: Backstage-Callbacks, die einen Wert zurückliefern, verwenden in VBA ByRef<\/b>-Parameter statt Funktionsrückgabewerten. Die Signatur für einen Text-Callback sieht zum Beispiel so aus:<\/p>\n
      Public Sub <\/span>ebServername_GetText(control As <\/span>IRibbonControl, _\r\n        ByRef text)\r\n    text = GetSetting(cStrAppName, _\r\n        cStrSection, \"Servername\", \"\")\r\nEnd Sub<\/span><\/pre>\n
      Falsche Signaturen führen zu stillen Fehlern – das Steuerelement zeigt einfach nichts an, ohne eine Fehlermeldung zu erzeugen.<\/p>\n
      Treiber-Auswahl<\/h2>\n
      Die erste Gruppe enthält ein dropDown<\/b>-Element für die Auswahl des ODBC-Treibers. Die drei verfügbaren Treiber sind im Code fest hinterlegt: ODBC Driver 17 for SQL Server<\/b>, ODBC Driver 18 for SQL Server <\/b>und SQL Server Native Client 11.0<\/b>. Das XML für das Dropdown sieht so aus:<\/p>\n
      <group id=\"grpTreiber\" label=\"Treiber\">\r\n  <topItems>\r\n    <dropDown id=\"ddTreiber\" label=\"ODBC-Treiber\"\r\n              getItemCount=\"ddTreiber_GetItemCount\"\r\n              getItemLabel=\"ddTreiber_GetItemLabel\"\r\n              getItemID=\"ddTreiber_GetItemID\"\r\n              getSelectedItemIndex=_\r\n                  \"ddTreiber_GetSelectedItemIndex\"\r\n              onAction=\"ddTreiber_OnAction\"\/>\r\n  <\/topItems>\r\n<\/group><\/pre>\n
      Die Callbacks für ein dropDown<\/b> im Backstage folgen einem einheitlichen Muster. GetItemCount<\/b> liefert die Anzahl der Einträge, GetItemLabel<\/b> den anzuzeigenden Text für jeden Index, GetItemID<\/b> eine eindeutige Zeichenkette je Eintrag und GetSelectedItemIndex<\/b> den aktuell gewählten Index. OnAction<\/b> wird aufgerufen, wenn der Benutzer einen Eintrag auswählt (siehe Listing 1).<\/p>\n
      Public Sub <\/span>ddTreiber_GetItemCount(control As <\/span>IRibbonControl, ByRef count)\r\n    count = 3\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ddTreiber_GetItemLabel(control As <\/span>IRibbonControl, index As Integer<\/span>, ByRef label)\r\n    label = GetTreiberName(index)\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ddTreiber_GetItemID(control As <\/span>IRibbonControl, index As Integer<\/span>, ByRef id)\r\n    id = \"treiber\" & index\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ddTreiber_GetSelectedItemIndex(control As <\/span>IRibbonControl, ByRef selectedIndex)\r\n    selectedIndex = Val(GetSetting(cStrAppName, cStrSection, \"TreiberIndex\", \"0\"))\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ddTreiber_OnAction(control As <\/span>IRibbonControl, selectedID As String<\/span>, selectedIndex As Integer<\/span>)\r\n    SaveSetting cStrAppName, cStrSection, \"TreiberIndex\", selectedIndex\r\n    Call<\/span> VerbindungszeichenfolgeAktualisieren\r\n    m_ribbon.Invalidate\r\nEnd Sub<\/span><\/pre>\n
      Listing 1: Callbacks für das Treiber-Dropdown<\/span><\/b><\/p>\n
      Die Hilfsfunktion GetTreiberName<\/b> liefert den Treibernamen für einen gegebenen Index und wird später auch beim Zusammenbauen der Verbindungszeichenfolge verwendet:<\/p>\n
      Private Function <\/span>GetTreiberName(index As Integer<\/span>) As String<\/span>\r\n    Select Case index\r\n        Case <\/span>0\r\n            GetTreiberName = \"ODBC Driver 17 for SQL Server\"\r\n        Case <\/span>1\r\n            GetTreiberName = \"ODBC Driver 18 for SQL Server\"\r\n        Case <\/span>2\r\n            GetTreiberName = \"SQL Server Native Client 11.0\"\r\n        Case Else<\/span>\r\n            GetTreiberName = \"ODBC Driver 17 for SQL Server\"\r\n    End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
      Um die Funktion VerbindungszeichenfolgeAktualisieren <\/b>kümmern wir uns weiter unten.<\/p>\n
      Servername mit History<\/h2>\n
      Für den Servernamen kommt eine comboBox<\/b> zum Einsatz – sie erlaubt sowohl freie Eingabe als auch die Auswahl aus einer Liste zuvor verwendeter Servernamen. Die verwendeten Namen werden pipe-separiert in der Registry gespeichert. Daneben gibt es einen Löschen<\/b>-Button, mit dem ein Servername aus der History entfernt werden kann. Beide Steuerelemente werden in einem layoutContainer<\/b> nebeneinander angeordnet:<\/p>\n
      <group id=\"grpServer\" label=\"Verbindung\">\r\n  <topItems>\r\n    <layoutContainer id=\"lcServername\"\r\n                    layoutChildren=\"horizontal\">\r\n      <comboBox id=\"cbServername\"\r\n                label=\"Servername\"\r\n                sizeString=\"WWWWWWWWWWWWWWWWWWWW\"\r\n                getText=\"cbServername_GetText\"\r\n                onChange=\"cbServername_OnChange\"\r\n                getItemCount=\"cbServername_GetItemCount\"\r\n                getItemLabel=\"cbServername_GetItemLabel\"\r\n                getItemID=\"cbServername_GetItemID\"\/>\r\n      <button id=\"btnServernameLoeschen\"\r\n              label=\"Löschen\"\r\n              imageMso=\"DeleteTable\"\r\n              onAction=_\r\n                  \"btnServernameLoeschen_OnAction\"\/>\r\n    <\/layoutContainer>\r\n    ...\r\n  <\/topItems>\r\n<\/group><\/pre>\n
      Die comboBox<\/b> kennt dieselben Item-Callbacks wie das dropDown<\/b>, zusätzlich aber getText<\/b> und onChange<\/b> für den frei eingebbaren Text. onChange<\/b> wird sowohl bei freier Eingabe als auch bei Auswahl aus der Liste aufgerufen. Der neue Servername wird dabei automatisch in der History gespeichert, sofern er noch nicht vorhanden ist.<\/p>\n
      Bevor wir uns die Callbacks anschauen, werfen wir einen Blick auf die Prozeduren, mit denen wir die Servernamen laden und einen neu eingegebenen Servernamen speichern. Diese finden wir in Listing 2.<\/p>\n
      Private <\/span>m_astrServernamen() As String<\/span>\r\nPrivate <\/span>m_intServernamenAnzahl As Integer<\/span>\r\nPrivate Sub <\/span>ServernamenLaden()\r\n    Dim <\/span>strListe As String<\/span>\r\n    strListe = GetSetting(cStrAppName, cStrSection, \"Servernamen\", \"\")\r\n    If <\/span>Len<\/span>(strListe) = 0 Then<\/span>\r\n        m_intServernamenAnzahl = 0\r\n        ReDim m_astrServernamen(0)\r\n        Exit Sub<\/span>\r\n    End If<\/span>\r\n    m_astrServernamen = Split<\/span>(strListe, \"|\")\r\n    m_intServernamenAnzahl = UBound<\/span>(m_astrServernamen) + 1\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>ServernameHinzufuegen(strName As String<\/span>)\r\n    Dim <\/span>i As Integer<\/span>\r\n    If <\/span>Len<\/span>(strName) = 0 Then<\/span> Exit Sub<\/span>\r\n    Call<\/span> ServernamenLaden\r\n    For i = 0 To m_intServernamenAnzahl - 1\r\n        If <\/span>LCase(m_astrServernamen(i)) = LCase(strName) Then<\/span>\r\n            Exit Sub<\/span>\r\n        End If<\/span>\r\n    Next<\/span> i\r\n    If <\/span>m_intServernamenAnzahl = 0 Then<\/span>\r\n        ReDim m_astrServernamen(0)\r\n    Else<\/span>\r\n        ReDim Preserve m_astrServernamen(m_intServernamenAnzahl)\r\n    End If<\/span>\r\n    m_astrServernamen(m_intServernamenAnzahl) = strName\r\n    m_intServernamenAnzahl = m_intServernamenAnzahl + 1\r\n    SaveSetting cStrAppName, cStrSection, \"Servernamen\", Join(m_astrServernamen, \"|\")\r\nEnd Sub<\/span><\/pre>\n
      Listing 2: History der Servernamen laden und ergänzen<\/span><\/b><\/p>\n
      Hier verwenden wir das Array m_astrServernamen<\/b> zum Speichern der Servernamen und die Variable m_intServernamenAnzahl <\/b>zum Speichern der Anzahl der enthaltenen Einträge.<\/p>\n
      Die Prozedur ServernamenLaden <\/b>holt mit GetSetting <\/b>die aktuelle Liste der Servernamen aus der Registry und prüft, ob diese leer ist. In diesem Fall werden die Variablen auf die Anzahl 0 <\/b>eingestellt beziehungsweise das Array geleert. Anderenfalls lesen wir die Liste mit der Split<\/b>-Funktion als Array in m_astrServernamen <\/b>ein und ermitteln die Anzahl mit der UBound<\/b>-Funktion.<\/p>\n
      Die Prozedur ServernameHinzufuegen <\/b>hängt den als Parameter angegebenen Servernamen an die Liste der Servernamen an. Dazu lädt sie die Liste und durchläuft alle Einträge. Ist der Eintrag bereits vorhanden, wird er nicht erneut angelegt. Anderenfalls wird er hinten an die Liste angehängt. Danach werden die beiden Variablen m_astrServernamen <\/b>und m_intServernamenAnzahl <\/b>aktualisiert und die Liste der Servernamen wieder in der Registry gespeichert.<\/p>\n
      Callback-Funktionen für die Server-ComboBox<\/h2>\n
      Nun folgen die ComboBox<\/b>-Callbacks, die auf das Array zurückgreifen (siehe Listing 3):<\/p>\n
      Public Sub <\/span>cbServername_GetText(control As <\/span>IRibbonControl, ByRef text)\r\n    text = GetSetting(cStrAppName, cStrSection, \"Servername\", \"\")\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>cbServername_OnChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n    SaveSetting cStrAppName, cStrSection, \"Servername\", text\r\n    Call<\/span> ServernameHinzufuegen(text)\r\n    Call<\/span> DatenbanknamenLeeren\r\n    Call<\/span> VerbindungszeichenfolgeAktualisieren\r\n    m_ribbon.Invalidate\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>cbServername_GetItemCount(control As <\/span>IRibbonControl, ByRef count)\r\n    Call<\/span> ServernamenLaden\r\n    count = m_intServernamenAnzahl\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>cbServername_GetItemLabel(control As <\/span>IRibbonControl, index As Integer<\/span>, ByRef label)\r\n    label = m_astrServernamen(index)\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>cbServername_GetItemID(control As <\/span>IRibbonControl, index As Integer<\/span>, ByRef id)\r\n    id = \"server\" & index\r\nEnd Sub<\/span><\/pre>\n
      Listing 3: Callback-Funktionen für die ComboBox zur Auswahl des Servernamens<\/span><\/b><\/p>\n
        \n
      • cbServername_GetText <\/b>liest den Text für den aktuellen Eintrag direkt aus der Registry-Einstellung Servername ein.<\/li>\n
      • cbServername_OnChange <\/b>wird ausgelöst, wenn der Benutzer einen anderen Eintrag auswählt. Dies speichert den gewählten Eintrag für die Einstellung Servername in der Registry. Außerdem werden die drei Prozeduren ServernameHinzufuegen<\/b>, DatenbanknamenLeeren <\/b>und VerbindungszeichenfolgeAktualisieren <\/b>aufgerufen, damit die übrigen Elemente aktualisiert werden – gefolgt vom Aufruf der Invalidate<\/b>-Methode, um die Aktualisierungen im Backstage-Bereich sichtbar zu machen.<\/li>\n
      • cbServername_GetItemCount <\/b>ruft die Prozedur ServernamenLaden <\/b>auf, was die aktuellen Servernamen aus der Registry einliest und die Anzahl der Einträge für das ComboBox<\/b>-Element zurückgibt.<\/li>\n
      • cbServername_GetItemLabel <\/b>wird für jeden Eintrag einmal aufgerufen und trägt den Text für den jeweiligen Server ein.<\/li>\n
      • cbServername_GetItemID <\/b>holt den passenden Index für die Einträge.<\/li>\n<\/ul>\n
        Löschen-Button für den Servernamen<\/h2>\n
        Der Löschen<\/b>-Button fragt vor dem Entfernen nach und schreibt die bereinigte Liste zurück in die Registry. Dazu verwenden wir die OnAction<\/b>-Prozedur aus Listing 4. Er holt den aktuellen Namen aus der Registry. Wenn dieser nicht leer ist, folgt die Rückfrage, ob der Eintrag gelöscht werden soll. Falls ja, werden alle Einträge geladen und nur die Einträge, die nicht mit dem zu löschenden Eintrag übereinstimmen, werden zum Array asstrNeu <\/b>hinzugefügt. Ist die Liste leer, wird der Eintrag Servernamen <\/b>in der Registry auf eine leere Zeichenkette eingestellt, anderenfalls wird aus dem Array mit der Join-Funktion eine durch das Pipe-Zeichen getrennte Liste der Servernamen in der Registry gespeichert und die Anzeige aktualisiert.<\/p>\n
        Public Sub <\/span>btnServernameLoeschen_OnAction(control As <\/span>IRibbonControl)\r\n    Dim <\/span>strName As String<\/span>\r\n    Dim <\/span>astrNeu() As String<\/span>\r\n    Dim <\/span>intNeu As Integer<\/span>\r\n    Dim <\/span>i As Integer<\/span>\r\n    strName = GetSetting(cStrAppName, cStrSection, \"Servername\", \"\")\r\n    If <\/span>Len<\/span>(strName) = 0 Then<\/span>\r\n        MsgBox<\/span> \"Kein Servername eingetragen.\", vbExclamation\r\n        Exit Sub<\/span>\r\n    End If<\/span>\r\n    If <\/span>MsgBox<\/span>(\"Servername ''\" & strName & \"'' aus der Liste löschen?\", vbQuestion + vbYesNo) = vbNo Then<\/span>\r\n        Exit Sub<\/span>\r\n    End If<\/span>\r\n    Call<\/span> ServernamenLaden\r\n    ReDim astrNeu(m_intServernamenAnzahl)\r\n    For i = 0 To m_intServernamenAnzahl - 1\r\n        If <\/span>LCase(m_astrServernamen(i)) <> LCase(strName) Then<\/span>\r\n            astrNeu(intNeu) = m_astrServernamen(i)\r\n            intNeu = intNeu + 1\r\n        End If<\/span>\r\n    Next<\/span> i\r\n    If <\/span>intNeu = 0 Then<\/span>\r\n        SaveSetting cStrAppName, cStrSection, \"Servernamen\", \"\"\r\n    Else<\/span>\r\n        ReDim Preserve astrNeu(intNeu - 1)\r\n        SaveSetting cStrAppName, cStrSection, \"Servernamen\", Join(astrNeu, \"|\")\r\n    End If<\/span>\r\n    Call<\/span> ServernamenLaden\r\n    m_ribbon.Invalidate\r\nEnd Sub<\/span><\/pre>\n
        Listing 4: Löschen-Button für die Servername-History<\/span><\/b><\/p>\n
        Datenbanken laden<\/h2>\n
        Nach der Eingabe des Servernamens und der Authentifizierungsdaten kann die Liste der verfügbaren Datenbanken vom Server abgerufen werden. Da dieser Vorgang eine Netzwerkverbindung aufbaut und je nach Server mehrere Sekunden dauern kann, erfolgt er nicht automatisch, sondern erst auf expliziten Klick auf den Button “Datenbanken mit aktuellen Zugangsdaten laden”. Die Ergebnisse werden in einer comboBox<\/b> für den Datenbanknamen angezeigt:<\/p>\n
        <button id=\"btnDatenbankenLaden\"   label=\"Datenbanken mit aktuellen Zugangsdaten laden\"   imageMso=\"RefreshAll\"  onAction=\"btnDatenbankenLaden_OnAction\"\/>\r\n<comboBox id=\"cbDatenbankname\" label=\"Datenbankname\"\r\n  sizeString=\"WWWWWWWWWWWWWWWWWWWW\"  getText=\"cbDatenbankname_GetText\"\r\n  onChange=\"cbDatenbankname_OnChange\"\r\n  getItemCount=\"cbDatenbankname_GetItemCount\"\r\n  getItemLabel=\"cbDatenbankname_GetItemLabel\"\r\n  getItemID=\"cbDatenbankname_GetItemID\"\/><\/pre>\n
        Für die Datenbanknamen werden zwei Modulvariablen benötigt – ein Array für die Namen und ein Zähler. Die Prozedur DatenbanknamenLeeren<\/b> setzt beide zurück und wird aufgerufen, sobald der Servername geändert wird – die Liste wäre für den neuen Server nicht mehr gültig:<\/p>\n
        Private <\/span>m_astrDatenbanknamen() As String<\/span>\r\nPrivate <\/span>m_intDatenbanknamenAnzahl As Integer<\/span>\r\nPrivate Sub <\/span>DatenbanknamenLeeren()\r\n    m_intDatenbanknamenAnzahl = 0\r\n    ReDim m_astrDatenbanknamen(0)\r\nEnd Sub<\/span><\/pre>\n
        Der Callback btnDatenbankenLaden_OnAction<\/b> baut eine Verbindungszeichenfolge ohne Datenbankangabe auf – nur Treiber, Server und Authentifizierung – und fragt per ADODB die Systemansicht sys.databases<\/b> ab. Jede gefundene Datenbank landet im Array (siehe Listing 5).<\/p>\n
        Public Sub <\/span>btnDatenbankenLaden_OnAction(control As <\/span>IRibbonControl)\r\n    Dim <\/span>cn As Object<\/span>, rs As Object<\/span>\r\n    Dim <\/span>strServer As String<\/span>\r\n    Dim <\/span>strConnect As String<\/span>\r\n    Dim <\/span>intAuth As Integer<\/span>\r\n    Dim <\/span>intTreiber As Integer<\/span>\r\n    strServer = GetSetting(cStrAppName, cStrSection, \"Servername\", \"\")\r\n    If <\/span>Len<\/span>(strServer) = 0 Then<\/span>\r\n        MsgBox<\/span> \"Bitte zuerst einen Servernamen\" & \" eingeben.\", vbExclamation\r\n        Exit Sub<\/span>\r\n    End If<\/span>\r\n    intAuth = Val(GetSetting(cStrAppName, cStrSection, \"Authentifizierung\", \"0\"))\r\n    intTreiber = Val(GetSetting(cStrAppName, cStrSection, \"TreiberIndex\", \"0\"))\r\n    strConnect = \"Driver={\" & GetTreiberName(intTreiber) & \"};Server=\" & strServer & \";\"\r\n    If <\/span>intAuth = 1 Then<\/span>\r\n        strConnect = strConnect & \"UID=\" & GetSetting(cStrAppName, cStrSection, \"Benutzername\", \"\") & \";PWD=\" _\r\n            & GetSetting(cStrAppName, cStrSection, \"Kennwort\", \"\") & \";\"\r\n    Else<\/span>\r\n        strConnect = strConnect & \"Trusted_Connection=Yes;\"\r\n    End If<\/span>\r\n    If <\/span>intTreiber = 1 Then<\/span>\r\n        strConnect = strConnect & \"Encrypt=yes;\" & \"TrustServerCertificate=yes;\"\r\n    End If<\/span>\r\n    On Error GoTo<\/span> Fehler\r\n    Set<\/span> cn = CreateObject(\"ADODB.Connection\")\r\n    cn.Open strConnect\r\n    Set<\/span> rs = cn.Execute(\"SELECT name FROM sys.databases ORDER BY name\")\r\n    Call<\/span> DatenbanknamenLeeren\r\n    Do While<\/span> Not<\/span> rs.EOF\r\n        If <\/span>m_intDatenbanknamenAnzahl = 0 Then<\/span>\r\n            ReDim m_astrDatenbanknamen(0)\r\n        Else<\/span>\r\n            ReDim Preserve m_astrDatenbanknamen(m_intDatenbanknamenAnzahl)\r\n        End If<\/span>\r\n        m_astrDatenbanknamen(m_intDatenbanknamenAnzahl) = rs.Fields(0).Value\r\n        m_intDatenbanknamenAnzahl = m_intDatenbanknamenAnzahl + 1\r\n        rs.MoveNext<\/span>\r\n    Loop<\/span>\r\n    rs.Close\r\n    cn.Close\r\n    Set<\/span> rs = Nothing\r\n    Set<\/span> cn = Nothing\r\n    m_ribbon.Invalidate\r\n    Exit Sub<\/span>\r\nFehler:\r\n    MsgBox<\/span> \"Fehler beim Laden der Datenbanken:\" & vbCrLf<\/span> & Err.Description, vbCr<\/span>itical\r\nEnd Sub<\/span><\/pre>\n
        Listing 5: Datenbanknamen vom Server laden<\/span><\/b><\/p>\n
        Dazu holt sie zuerst den Servernamen, die Authentizifierungsmethode und den Index des aktuell selektierten Treibers aus der Registry und stellt damit in strConnect <\/b>die Verbindungszeichenfolge zusammen – bei SQL Server-Authentifizierung mit Benutzer und Kennwort und bei Windows-Authentifizierung mit Trusted_Connection=Yes<\/b>. Falls wir den ODBC Driver 18 for SQL Server <\/b>nutzen, hängen wir noch die Paraemter Encrypt <\/b>und TrustServerCertificate <\/b>jeweils mit dem Wert Yes an die Verbindungszeichenfolge an.<\/p>\n
        Dann baut die Prozedur mit einem Connection<\/b>-Objekt eine Verbindung zur Tabelle sys.databases <\/b>auf und ermittelt alle enthaltenen Einträge in einem Recordset. Dieses durchläuft sie anschließend in einer Do While<\/b>-Schleife und füllt das Array m_intDatenbanknamen <\/b>mit den Datenbanknamen.<\/p>\n
        Nach m_ribbon.Invalidate<\/b> fragt Access alle Callbacks neu ab – die ComboBox zeigt dann die geladenen Datenbanken an. Die fünf Callbacks der Datenbankname-ComboBox sind analog zu denen der Servername-ComboBox aufgebaut (siehe Listing 6).<\/p>\n
        Public Sub <\/span>cbDatenbankname_GetText(control As <\/span>IRibbonControl, ByRef text)\r\n    text = GetSetting(cStrAppName, cStrSection, \"Datenbankname\", \"\")\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>cbDatenbankname_OnChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n    SaveSetting cStrAppName, cStrSection, \"Datenbankname\", text\r\n    Call<\/span> VerbindungszeichenfolgeAktualisieren\r\n    m_ribbon.Invalidate\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>cbDatenbankname_GetItemCount(control As <\/span>IRibbonControl, ByRef count)\r\n    count = m_intDatenbanknamenAnzahl\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>cbDatenbankname_GetItemLabel(control As <\/span>IRibbonControl, index As Integer<\/span>, ByRef label)\r\n    label = m_astrDatenbanknamen(index)\r\n    Debug.Print<\/span> label\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>cbDatenbankname_GetItemID(control As <\/span>IRibbonControl, index As Integer<\/span>, ByRef id)\r\n    id = \"datenbank\" & index\r\nEnd Sub<\/span><\/pre>\n
        Listing 6: Callbacks für die Datenbankname-ComboBox<\/span><\/b><\/p>\n
        Authentifizierung<\/h2>\n
        SQL Server unterstützt zwei Authentifizierungsarten: Windows-Authentifizierung, bei der die Anmeldedaten des aktuellen Windows-Benutzers verwendet werden, und SQL Server-Authentifizierung mit eigenem Benutzernamen und Kennwort. Eine radioGroup<\/b> mit zwei radioButton<\/b>-Elementen steuert die Auswahl. Die Eingabefelder für Benutzername und Kennwort werden über getEnabled<\/b>-Callbacks dynamisch aktiviert und deaktiviert:<\/p>\n
        <group id=\"grpAuthentifizierung\"\r\n        label=\"Authentifizierung\">\r\n  <topItems>\r\n    <radioGroup id=\"rgAuthentifizierung\"\r\n        getSelectedItemIndex=\r\n          \"rgAuthentifizierung_GetSelectedItemIndex\"\r\n        onAction=\"rgAuthentifizierung_OnAction\">\r\n      <radioButton id=\"rbWindows\"\r\n        label=\"Windows-Authentifizierung\"\/>\r\n      <radioButton id=\"rbSQL\"\r\n        label=\"SQL Server-Authentifizierung\"\/>\r\n    <\/radioGroup>\r\n    <editBox id=\"ebBenutzername\"\r\n      label=\"Benutzername\"\r\n      sizeString=\"WWWWWWWWWWWWWWWWWWWW\"\r\n      getText=\"ebBenutzername_GetText\"\r\n      onChange=\"ebBenutzername_OnChange\"\r\n      getEnabled=\"ebBenutzername_GetEnabled\"\/>\r\n    <editBox id=\"ebKennwort\"\r\n      label=\"Kennwort\"\r\n      sizeString=\"WWWWWWWWWWWWWWWWWWWW\"\r\n      getText=\"ebKennwort_GetText\"\r\n      onChange=\"ebKennwort_OnChange\"\r\n      getEnabled=\"ebKennwort_GetEnabled\"\/>\r\n  <\/topItems>\r\n<\/group><\/pre>\n
        Ein wichtiges Detail bei der radioGroup<\/b>: Der onAction<\/b>-Callback erwartet den Index als Long<\/b>-Parameter – nicht als Integer<\/b>. Eine falsche Deklaration führt zu einem stillen Fehler, der schwer zu diagnostizieren ist. Die beiden Callbacks für die RadioGroup sehen wir in Listing 7.<\/p>\n
        Public Sub <\/span>rgAuthentifizierung_GetSelectedItemIndex(control As <\/span>IRibbonControl, ByRef selectedIndex)\r\n    selectedIndex = Val(GetSetting(cStrAppName, cStrSection, \"Authentifizierung\", \"0\"))\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>rgAuthentifizierung_OnAction(control As <\/span>IRibbonControl, selectedID As String<\/span>, selectedIndex As Long<\/span>)\r\n    SaveSetting cStrAppName, cStrSection, \"Authentifizierung\", selectedIndex\r\n    Call<\/span> VerbindungszeichenfolgeAktualisieren\r\n    m_ribbon.Invalidate\r\nEnd Sub<\/span><\/pre>\n
        Listing 7: Callbacks für die RadioGroup für die Authentifizierungsmethode<\/span><\/b><\/p>\n
        Für Benutzername und Kennwort benötigen wir jeweils die Callbacks für getText<\/b>, onChange <\/b>und getEnabled<\/b>. Diese finden wir in Listing 8.<\/p>\n
        Public Sub <\/span>ebBenutzername_GetEnabled(control As <\/span>IRibbonControl, ByRef enabled)\r\n    enabled = (Val(GetSetting(cStrAppName, cStrSection, \"Authentifizierung\", \"0\")) = 1)\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ebBenutzername_OnChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n    SaveSetting cStrAppName, cStrSection, \"Benutzername\", text\r\n    Call<\/span> VerbindungszeichenfolgeAktualisieren\r\n    m_ribbon.Invalidate\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ebBenutzername_GetText(control As <\/span>IRibbonControl, ByRef text)\r\n    text = GetSetting(cStrAppName, cStrSection, \"Benutzername\", \"\")\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ebKennwort_GetText(control As <\/span>IRibbonControl, ByRef text)\r\n    text = GetSetting(cStrAppName, cStrSection, \"Kennwort\", \"\")\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ebKennwort_OnChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n    SaveSetting cStrAppName, cStrSection, \"Kennwort\", text\r\n    Call<\/span> VerbindungszeichenfolgeAktualisieren\r\n    m_ribbon.Invalidate\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>ebKennwort_GetEnabled(control As <\/span>IRibbonControl, ByRef enabled)\r\n    enabled = (Val(GetSetting(cStrAppName, cStrSection, \"Authentifizierung\", \"0\")) = 1)\r\nEnd Sub<\/span><\/pre>\n
        Listing 8: Callbacks für die Steuerelemente ebBenutzername und ebKennwort<\/span><\/b><\/p>\n
        Die getText<\/b>-Callbacks lesen jeweils den Benutzernamen und das Kennwort aus der Registry ein.<\/p>\n
        Die onChange<\/b>-Callbacks werden ausgelöst, wenn der Benutzer einen der Einträge ändert. Sie sorgen dafür, dass die neuen Werte in der Registry gespeichert werden, und die Verbindungszeichenfolge und die Steuerelemente des Ribbons aktualisiert werden.<\/p>\n
        Die getEnabled<\/b>-Callbacks sorgen dafür, dass die beiden Steuerelemente ebBenutzername und ebKennwort nur aktiviert werden, wenn als Authentifizierungsmethode SQL Server-Authentifizierung <\/b>ausgewählt ist.<\/p>\n
        Verbindungszeichenfolge<\/h2>\n
        Die letzte Gruppe zeigt die fertig zusammengesetzte Verbindungszeichenfolge an und stellt zwei Buttons bereit. Das Attribut style=”warning”<\/b> gibt der Gruppe einen farblichen Hintergrund und hebt sie optisch vom Rest ab. Ein labelControl<\/b> zeigt den aktuellen Wert, ein layoutContainer<\/b> ordnet die zwei Buttons nebeneinander an:<\/p>\n
        <group id=\"grpVerbindungszeichenfolge\"\r\n   label=\"Verbindungszeichenfolge\" style=\"warning\">\r\n  <topItems>\r\n    <labelControl id=\"lblVerbindungszeichenfolge\"\r\n      getLabel=        \"lblVerbindungszeichenfolge_GetLabel\"\/>\r\n    <layoutContainer id=\"lcVerbindung\"\r\n        layoutChildren=\"horizontal\">\r\n      <button id=\"btnVerbindungTesten\"\r\n        label=\"Verbindung testen\"\r\n        imageMso=\"RefreshAll\"\r\n        onAction=\"btnVerbindungTesten_OnAction\"\/>\r\n      <button id=\"btnVerbindungszeichenfolgeKopieren\"\r\n        label=\"In Zwischenablage kopieren\"\r\n        imageMso=\"Copy\"\r\n        onAction=\r\n          \"btnVerbindungszeichenfolgeKopieren_OnAction\"\/>\r\n    <\/layoutContainer>\r\n  <\/topItems>\r\n<\/group><\/pre>\n
        Die Prozedur VerbindungszeichenfolgeAktualisieren<\/b> wird von allen Callbacks aufgerufen, die einen der Eingabewerte ändern. Sie liest alle Einzelwerte aus der Registry und setzt sie zur fertigen Zeichenfolge zusammen. Für den ODBC Driver 18 werden zusätzliche Parameter für die verschlüsselte Verbindung ergänzt (siehe Listing 9).<\/p>\n
        Private Sub <\/span>VerbindungszeichenfolgeAktualisieren()\r\n    Dim <\/span>str As String<\/span>\r\n    Dim <\/span>intAuth As Integer<\/span>\r\n    Dim <\/span>intTreiber As Integer<\/span>\r\n    intAuth = Val(GetSetting(cStrAppName, cStrSection, \"Authentifizierung\", \"0\"))\r\n    intTreiber = Val(GetSetting(cStrAppName, cStrSection, \"TreiberIndex\", \"0\"))\r\n    str = \"Driver={\" & GetTreiberName(intTreiber) & \"};\" & \"Server=\" & GetSetting(cStrAppName, cStrSection, _\r\n        \"Servername\", \"\") & \";\" & \"Database=\" & GetSetting(cStrAppName, cStrSection, \"Datenbankname\", \"\") & \";\"\r\n    If <\/span>intAuth = 1 Then<\/span>\r\n        str = str & \"UID=\" & GetSetting(cStrAppName, cStrSection, \"Benutzername\", \"\") & \";\" & \"PWD=\" _\r\n            & GetSetting(cStrAppName, cStrSection, \"Kennwort\", \"\") & \";\"\r\n    Else<\/span>\r\n        str = str & \"Trusted_Connection=Yes;\"\r\n    End If<\/span>\r\n    If <\/span>intTreiber = 1 Then<\/span>\r\n        str = str & \"Encrypt=yes;TrustServerCertificate=yes;\"\r\n    End If<\/span>\r\n    SaveSetting cStrAppName, cStrSection, \"Verbindungszeichenfolge\", str\r\nEnd Sub<\/span><\/pre>\n
        Listing 9: Verbindungszeichenfolge zusammenbauen<\/span><\/b><\/p>\n
        Das Label zeigt die Zeichenfolge mit Zeilenumbrüchen nach jedem Semikolon an. Der getLabel<\/b>-Callback ersetzt dazu alle Semikolons durch ein Semikolon gefolgt von einem Zeilenvorschub:<\/p>\n
        Public Sub <\/span>lblVerbindungszeichenfolge_GetLabel( _\r\n        control As <\/span>IRibbonControl, ByRef label)\r\n    Dim <\/span>str As String<\/span>\r\n    str = GetSetting(cStrAppName, _\r\n        cStrSection, \"Verbindungszeichenfolge\", \"\")\r\n    label = Replace<\/span>(str, \";\", \";\" & vbLf<\/span>)\r\nEnd Sub<\/span><\/pre>\n
        Der Verbindungstest öffnet per ADODB eine Verbindung mit der gespeicherten Zeichenfolge und schließt sie sofort wieder. Bei Erfolg erscheint eine Bestätigungsmeldung, bei einem Fehler die Beschreibung von ADODB:<\/p>\n
        Public Sub <\/span>btnVerbindungTesten_OnAction( _\r\n        control As <\/span>IRibbonControl)\r\n    Dim <\/span>cn As Object<\/span>\r\n    On Error GoTo<\/span> Fehler\r\n    Set<\/span> cn = CreateObject(\"ADODB.Connection\")\r\n    cn.Open GetSetting(cStrAppName, _\r\n        cStrSection, \"Verbindungszeichenfolge\", \"\")\r\n    cn.Close\r\n    Set<\/span> cn = Nothing\r\n    MsgBox<\/span> \"Verbindung erfolgreich.\", vbInformation\r\n    Exit Sub<\/span>\r\nFehler:\r\n    MsgBox<\/span> \"Verbindung fehlgeschlagen:\" _\r\n        & vbCrLf<\/span> & Err.Description, vbCr<\/span>itical\r\nEnd Sub<\/span><\/pre>\n
        Das Kopieren in die Zwischenablage gelingt in VBA ohne externe Bibliotheken über ein temporäres Forms.TextBox<\/b>-Objekt. Der Text wird eingetragen, vollständig markiert und per Copy<\/b>-Methode übertragen:<\/p>\n
        Public Sub <\/span>btnVerbindungszeichenfolgeKopieren_OnAction( _\r\n        control As <\/span>IRibbonControl)\r\n    Dim <\/span>str As String<\/span>\r\n    str = GetSetting(cStrAppName, _\r\n        cStrSection, \"Verbindungszeichenfolge\", \"\")\r\n    If <\/span>Len<\/span>(str) = 0 Then<\/span>\r\n        MsgBox<\/span> \"Die Verbindungszeichenfolge\" _\r\n            & \" ist leer.\", vbExclamation\r\n        Exit Sub<\/span>\r\n    End If<\/span>\r\n    With<\/span> CreateObject(\"Forms.TextBox.1\")\r\n        .MultiLine = True<\/span>\r\n        .Text = str\r\n        .SelStart = 0\r\n        .SelLength = Len<\/span>(str)\r\n        .Copy\r\n    End With<\/span>\r\n    MsgBox<\/span> \"In die Zwischenablage kopiert.\", _\r\n        vbInformation\r\nEnd Sub<\/span><\/pre>\n
        Schritte zum Implementieren der Lösung in eine eigene Datenbank<\/h2>\n
        Um die hier vorgestellte Lösung in einer eigenen Datenbank zu verwenden, sind die folgenden Schritte nötig:<\/p>\n
          \n
        • Hinzufügen der Tabelle USysRibbons<\/b><\/li>\n
        • Einstellen des Menübands der Anwendung auf den verwendeten Ribbon-Namen<\/li>\n
        • Hinzufügen des Moduls mdlBackstage<\/b><\/li>\n
        • Hinzufügen eines Verweises auf die Bibliothek Microsoft Office 16.0 Object Library<\/b><\/li>\n<\/ul>\n
          Zusammenfassung und Ausblick<\/h2>\n
          Der Backstage-Bereich von Access bietet deutlich mehr Platz als das Ribbon und eignet sich gut für Konfigurationsdialoge, die dauerhaft erreichbar sein sollen. Die hier vorgestellte Lösung zeigt, wie sich mit überschaubarem VBA-Code ein vollständiger Verbindungsassistent für SQL Server direkt in Access integrieren lässt – ohne separate Formulare und ohne externe Abhängigkeiten.<\/p>\n
          Zwei Details verdienen besondere Aufmerksamkeit: Alle Get-Callbacks im Backstage verwenden ByRef<\/b>-Parameter statt Funktionsrückgabewerten – falsche Signaturen führen zu stillen Fehlern ohne Fehlermeldung. Und der onAction<\/b>-Callback der radioGroup<\/b> erwartet den Index als Long<\/b>, nicht als Integer<\/b>.<\/p>\n
          Die Lösung lässt sich noch erweitern. Wir könnten zum Beispiel einen weiteren Bereich hinzufügen, indem wir alle in der aktuellen Datenbank verwendeten Verbindungen anzeigen und verwalten.<\/p>\n
          Oder wir fügen Elemente hinzu, mit denen wir die aktuell zusammengestellten Verbindungsinformationen speichern können, um diese anschließend wieder aufzurufen. Wenn wir alle Verbindungen gespeichert haben, können wir so von allen Datenbanken auf diese zugreifen, in denen wir diese Backstage-Definition integriert haben.<\/p>\n
          Wir können auch noch Funktionen hinzufügen, mit denen wir einzelne oder auch alle Tabellen der aktuellen Verbindung als Tabellenverknüpfung zur geöffneten Access-Datenbank hinzufügen.<\/p>\n
          Und als krönenden Abschluss könnten wir die Backstage-Erweiterung, die wir hier in eine einzelne Access-Datenbank integriert haben, in Form eines COM-Add-Ins realisieren, damit die Funktionalität fortan in allen Access-Datenbanken zur Verfügung steht.<\/p>\n","protected":false},"excerpt":{"rendered":"
          Wer in Access mit verknüpften SQL Server-Tabellen arbeitet, kennt das Problem: Die Verbindungszeichenfolge muss korrekt zusammengesetzt sein, Treiber und Authentifizierungsart müssen stimmen – und bei jeder neuen Datenbank fängt man von vorn an. Dieser Artikel zeigt, wie Du einen eigenen Tab im Backstage-Bereich von Access einrichtest, der Dir das Zusammenbauen der Verbindungszeichenfolge abnimmt. <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66022026,662026,44000024,44000026,44000006,44000031],"tags":[],"yst_prominent_words":[],"class_list":["post-55000504","post","type-post","status-publish","format-standard","hentry","category-66022026","category-662026","category-Berichte_und_Reporting","category-Outlook_programmieren","category-SQL_Server_und_Co","category-twinBASICProgrammierung"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000504","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000504"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000504\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000504"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000504"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000504"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000504"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}