{"id":55001612,"date":"2026-08-01T00:00:00","date_gmt":"2026-07-05T11:03:27","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1612"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBAModule_regelmaessig_sichern_per_COMAddIn","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/","title":{"rendered":"VBA-Module regelmäßig sichern per COM-Add-In"},"content":{"rendered":"

Wer viel in VBA programmiert, kennt den Schreck: Ein Absturz von Access, und die Arbeit der letzten halben Stunde ist weg. Natürlich kann man von Hand speichern – aber genau das vergisst man im Eifer des Gefechts. In diesem Beitrag bauen wir uns einen fleißigen Helfer, der uns diese Sorge abnimmt: ein COM-Add-In für den Access-Entwickler, das in einstellbaren Abständen alle geänderten Formulare, Berichte und Module automatisch in einzelne Textdateien sichert. So haben wir immer eine frische Kopie unseres Codes zur Hand, ganz ohne daran zu denken.<\/b><\/p>\n

Was der Helfer leisten soll<\/h2>\n

Bevor wir in den Code schauen, halten wir kurz fest, was das Add-In eigentlich tun soll. In regelmäßigen Abständen – zum Beispiel alle fünf Minuten – sieht es nach, welche Module im aktuellen Projekt seit dem letzten Speichern geändert wurden. Jedes solche Modul schreibt es als eigene Textdatei in einen Unterordner namens BAS<\/b>. Damit dabei nicht bei jedem Durchlauf sämtliche Module erneut gesichert werden, merkt sich das Add-In für jedes Modul einen kleinen Fingerabdruck des Inhalts und legt nur dann eine neue Datei an, wenn sich wirklich etwas geändert hat.<\/p>\n

Bedienen lässt sich der Helfer bequem über einen eigenen Bereich im Datei-Menü des VBA-Editors. Dort schalten wir die automatische Sicherung ein und aus, wählen das Zeitintervall und sehen auf einen Blick, welche Dateien zuletzt gesichert wurden. Wie dieser Bereich aussieht, zeigt Bild 1.<\/p>\n

\"Das<\/p>\n

Bild 1: Das COM-Add-In amvCodeBackup im Dateinmenü von Access<\/span><\/b><\/p>\n

In Bild 2 sehen Sie, wie das Intervall zum Exportieren der geänderten VBA-Module ausgewählt wird.<\/p>\n

\"Auswählen<\/p>\n

Bild 2: Auswählen des Intervalls zum Anlegen von Sicherungen<\/span><\/b><\/p>\n

Ein kleiner Wermutstropfen<\/h2>\n

Das Sichern bezieht sich nicht nur auf reine VBA-Module – auch wenn der Code in den Klassenmodulen von Formularen oder Berichten geändert wurden, werden diese gespeichert.<\/p>\n

Wenn allerdings der Code eines Formulars oder Berichts geändert wurde, muss dieses vor dem Exportieren der neuen Version zunächst gespeichert werden – daher erscheint in diesem Fall jeweils eine Meldung wie die aus Bild 3.<\/p>\n

\"Meldung<\/p>\n

Bild 3: Meldung vor dem Speichern von Formularen oder Berichten<\/span><\/b><\/p>\n

Damit dies beim Programmieren nicht zu sehr stört, empfiehlt es sich, das Intervall entsprechend hochzusetzen. Welches Intervall für Sie optimal funktioniert, probieren Sie am besten selbst aus. Ein kleineres Intervall bringt diese Meldung öfter hervor, ein größeres ist mit dem Risiko behaftet, dass bei einem Absturz von Access eventuell mehr Änderungen verloren gehen.<\/p>\n

Das Projekt in twinBASIC<\/h2>\n

Wie in früheren Beiträgen entsteht das COM-Add-In mit twinBASIC, das für die 32-Bit-Version kostenlos ist. Wie man ein solches Projekt von Grund auf anlegt, haben wir bereits an anderer Stelle gezeigt; hier konzentrieren wir uns darauf, wie das fertige Projekt amvCodeBackup<\/b> und der darin enthaltene Code funktionieren. Am bequemsten öffnen Sie die mitgelieferte Projektdatei und verfolgen die Bausteine parallel zum Beitrag.<\/p>\n

Das Projekt gliedert sich in drei Teile. Die Klasse amvCodeBackup<\/b> steuert den gesamten Ablauf. Das Modul mdlTimer<\/b> verbindet den Windows-Wecker mit der Sicherungsroutine, und das Modul DllRegistration<\/b> macht das Add-In gegenüber Access bekannt. Diese drei Teile gehen wir nun der Reihe nach durch.<\/p>\n

Der Kopf der Klasse<\/h2>\n

Ganz oben in der Klasse amvCodeBackup <\/b>steht die ClassId<\/b>, eine weltweit einmalige Nummer, unter der Windows das Add-In in der Registry wiederfindet. Sie wird von twinBASIC einmalig vergeben und danach nicht mehr angetastet, denn eine geänderte Nummer gälte als ein gänzlich anderes Objekt. Direkt darunter meldet die Klasse die beiden Bausteine an, die sie umsetzt. Hier sehen wir den Kopf der Klasse:<\/p>\n

[ClassId(\"DC8E7154-FAC8-43B7-88E5-A9352753999F\")]\r\nClass<\/span> amvCodeBackup\r\n    Implements IDTExtensibility2\r\n    [WithDispatchForwarding]\r\n    Implements IRibbonExtensibility<\/pre>\n
Eine Schnittstelle legt fest, welche Prozeduren eine Klasse bereitstellen muss. Über IDTExtensibility2<\/b> kann Office das Add-In starten und wieder beenden, und IRibbonExtensibility<\/b> öffnet uns den Weg, dem Menüband eigene Elemente hinzuzufügen. Die Angabe WithDispatchForwarding<\/b> in eckigen Klammern ist eine technische Markierung, die twinBASIC für das Ribbon benötigt.<\/p>\n
Was sich die Klasse merkt<\/h2>\n
Damit der Helfer arbeiten kann, hält er mehrere Verweise fest. Hier sehen wir diese im Überblick:<\/p>\n
Private <\/span>objAccess As <\/span>Access.Application\r\nPrivate <\/span>objVBE As <\/span>VBIDE.VBE\r\nPrivate <\/span>cbbCodeBackup As Object<\/span>\r\nPrivate <\/span>objRibbon As <\/span>IRibbonUI\r\nPrivate <\/span>WithEvents cbbCodeBackupEvents As <\/span>VBIDE.CommandBarEvents\r\nPrivate <\/span>cbbCodeBackupOptionen As Object<\/span>\r\nPrivate <\/span>WithEvents cbbCodeBackupOptionenEvents As <\/span>VBIDE.CommandBarEvents<\/pre>\n
In objAccess<\/b> liegt später Access selbst, in objVBE<\/b> der VBA-Editor mit seinen Projekten und Modulen – an ihn wenden wir uns, um an den Quellcode zu gelangen. In objRibbon<\/b> merken wir uns das Menüband, um seine Anzeige bei Bedarf auffrischen zu können. Die vier übrigen Variablen gehören zu zwei Einträgen, die wir zusätzlich in die Symbolleiste des Editors setzen: cbbCodeBackup<\/b> zum Ein- und Ausschalten und cbbCodeBackupOptionen<\/b> zum Einstellen des Intervalls. Das Schlüsselwort WithEvents<\/b> sorgt jeweils dafür, dass wir auf Klicks reagieren können.<\/p>\n
Ein Wecker aus Windows<\/h2>\n
Um in festen Abständen aktiv zu werden, borgt sich der Helfer eine Uhr von Windows. Die Funktion SetTimer<\/b> stellt einen Wecker, der nach der eingestellten Zeit auslöst, KillTimer<\/b> schaltet ihn wieder ab. Weil Access in einer 32- und einer 64-Bit-Version existiert und diese Funktionen dort geringfügig anders angesprochen werden, sind sie doppelt vereinbart. Welche Fassung gilt, entscheidet bereits beim Kompilieren die Abfrage #If Win64 Then<\/b> (siehe Listing 1).<\/p>\n
#If Win64 Then\r\n    Private <\/span>Declare PtrSafe Function SetTimer Lib \"user32\" (ByVal hWnd As Long<\/span>Ptr, ByVal nIDEvent As Long<\/span>Ptr, _\r\n        ByVal uElapse As Long<\/span>, ByVal lpTimerFunc As Long<\/span>Ptr) As Long<\/span>Ptr\r\n    Private <\/span>Declare PtrSafe Function KillTimer Lib \"user32\" (ByVal hWnd As Long<\/span>Ptr, ByVal nIDEvent As Long<\/span>Ptr) As Long<\/span>\r\n    Private <\/span>lngTimerID As Long<\/span>Ptr\r\n#Else\r\n    Private <\/span>Declare Function SetTimer Lib \"user32\" (ByVal hWnd As Long<\/span>, ByVal nIDEvent As Long<\/span>, _\r\n        ByVal uElapse As Long<\/span>, ByVal lpTimerFunc As Long<\/span>) As Long<\/span>\r\n    Private <\/span>Declare Function KillTimer Lib \"user32\" (ByVal hWnd As Long<\/span>, ByVal nIDEvent As Long<\/span>) As Long<\/span>\r\n    Private <\/span>lngTimerID As Long<\/span>\r\n#End If<\/pre>\n
Listing 1: Die Timer-Funktionen werden je nach Architektur passend deklariert<\/span><\/b><\/p>\n
SetTimer<\/b> liefert eine Kennnummer für den laufenden Wecker zurück, die wir in lngTimerID<\/b> ablegen. Solange sie ungleich null ist, wissen wir, dass der Timer arbeitet – ein bequemer Weg, den Ein-\/Aus-Zustand abzufragen.<\/p>\n
Das Intervall dauerhaft merken<\/h2>\n
Das gewählte Intervall soll einen Neustart von Access überdauern, deshalb legen wir es in der Registry ab. Unter welchem Namen und in welchem Abschnitt der Wert liegt, halten ein paar Konstanten fest; fehlt noch ein gespeicherter Wert, greifen 300 Sekunden als Vorgabe. Die Konstanten dazu sehen wir folgt aus:<\/p>\n
Private <\/span>Const REG_APP As String<\/span> = \"amvCodeBackup\"\r\nPrivate <\/span>Const REG_SECTION As String<\/span> = \"Optionen\"\r\nPrivate <\/span>Const REG_INTERVALL As String<\/span> = \"Intervall\"\r\nPrivate <\/span>Const REG_INTERVALL_DEFAULT As Long<\/span> = 300\r\nPrivate <\/span>Const MAX_RECENT As Integer<\/span> = 10<\/pre>\n
Das eigentliche Lesen und Schreiben übernehmen zwei winzige Prozeduren, die sich der fertigen VBA-Funktionen GetSetting<\/b> und SaveSetting<\/b> bedienen. Mehr als der gespeicherte Sekundenwert wandert hier nicht über die Leitung, wie folgende Listings belegen:<\/p>\n
Private Function <\/span>IntervallLesen() As Long<\/span>\r\n    IntervallLesen = CLng(GetSetting(REG_APP, REG_SECTION, _\r\n        REG_INTERVALL, REG_INTERVALL_DEFAULT))\r\nEnd Function<\/span>\r\nPrivate Sub <\/span>IntervallSchreiben(lngSekunden As Long<\/span>)\r\n    SaveSetting REG_APP, REG_SECTION, REG_INTERVALL, _\r\n        lngSekunden\r\nEnd Sub<\/span><\/pre>\n
Die Konstante MAX_RECENT<\/b> aus dem vorigen Listing legt übrigens fest, wie viele der zuletzt gesicherten Dateien wir später in der Liste anzeigen – hier also zehn.<\/p>\n
Die Oberfläche als XML beschreiben<\/h2>\n
Der Bereich im Datei-Menü wird nicht zusammengeklickt, sondern als XML beschrieben. Die Funktion GetCustomUI<\/b> setzt diesen Text Zeile für Zeile zusammen und reicht ihn an Office weiter. Der Vorteil dieser Trennung: Das XML bestimmt allein das Aussehen und die Anordnung, während der eigentliche Inhalt später aus dem Code kommt. Die Definition zeigt Listing 2.<\/p>\n
Private Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> Implements IRibbonExtensibility.GetCustomUI\r\n    Dim <\/span>strXML As String<\/span>\r\n    Dim <\/span>i As Integer<\/span>\r\n    strXML = \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\" onLoad=\"\"customUI_OnLoad\"\">\" & vbCrLf<\/span>\r\n    strXML = strXML & \"  <backstage>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"    <tab id=\"\"tabCodeBackup\"\" label=\"\"amvCodeBackup\"\" insertAfterMso=\"\"TabInfo\"\" \" _\r\n        & \"title=\"\"amvCodeBackup\"\">\" & vbCrLf<\/span>\r\n    strXML = strXML & \"      <firstColumn>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"        <group id=\"\"grpTimer\"\" label=\"\"Timer\"\">\" & vbCrLf<\/span>\r\n    strXML = strXML & \"          <topItems>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"            <button id=\"\"btnTimer\"\" getLabel=\"\"btnTimer_GetLabel\"\" \" _\r\n        & \"onAction=\"\"btnTimer_OnAction\"\"\/>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"            <dropDown id=\"\"ddIntervall\"\" label=\"\"Intervall\"\" \" _\r\n        & \"getSelectedItemIndex=\"\"ddIntervall_GetSelectedItemIndex\"\" onAction=\"\"ddIntervall_OnAction\"\">\" & vbCrLf<\/span>\r\n    strXML = strXML & \"              <item id=\"\"i10\"\" label=\"\"10 Sekunden\"\"\/>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"              <item id=\"\"i20\"\" label=\"\"20 Sekunden\"\"\/>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"              <item id=\"\"i30\"\" label=\"\"30 Sekunden\"\"\/>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"              <item id=\"\"i60\"\" label=\"\"1 Minute\"\"\/>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"              <item id=\"\"i120\"\" label=\"\"2 Minuten\"\"\/>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"              <item id=\"\"i300\"\" label=\"\"5 Minuten\"\"\/>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"              <item id=\"\"i600\"\" label=\"\"10 Minuten\"\"\/>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"            <\/dropDown>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"          <\/topItems>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"        <\/group>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"        <group id=\"\"grpRecent\"\" label=\"\"Zuletzt gesichert\"\">\" & vbCrLf<\/span>\r\n    strXML = strXML & \"          <topItems>\" & vbCrLf<\/span>\r\n    For i = 1 To MAX_RECENT\r\n        strXML = strXML & \"            <labelControl id=\"\"lblRecent\" & i & \"\"\" getLabel=\"\"lblRecent\" & i _\r\n            & \"_GetLabel\"\"\/>\" & vbCrLf<\/span>\r\n    Next<\/span> i\r\n    strXML = strXML & \"          <\/topItems>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"        <\/group>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"      <\/firstColumn>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"    <\/tab>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"  <\/backstage>\" & vbCrLf<\/span>\r\n    strXML = strXML & \"<\/customUI>\" & vbCrLf<\/span>\r\n    GetCustomUI = strXML\r\nEnd Function<\/span><\/pre>\n
Listing 2: Die Funktion GetCustomUI liefert die Ribbon-Definition.<\/span><\/b><\/p>\n
Das äußerste Element customUI<\/b> klammert alles ein und nennt über onLoad<\/b> die Prozedur, die Office einmal aufruft, sobald die Oberfläche geladen ist. Darin folgt backstage<\/b> – jener Bereich, der beim Klick auf Datei erscheint. Mit tab<\/b> legen wir dort eine eigene Seite an und schieben sie über insertAfterMso<\/b> hinter den vorhandenen Bereich. Die erste Gruppe grpTimer<\/b> enthält die Schaltfläche btnTimer<\/b> zum Umschalten und das Auswahlfeld ddIntervall<\/b> mit den festen Zeitstufen. Jedes Element nennt dabei die Funktionen, die es mit Leben füllen – etwa getLabel<\/b> für die Beschriftung und onAction<\/b> für die Reaktion auf einen Klick.<\/p>\n
Die zweite Gruppe listet die zuletzt gesicherten Dateien auf. Weil es davon zehn sind, wäre es mühsam, jede Zeile von Hand zu schreiben – eine Schleife erzeugt sie stattdessen.<\/p>\n
Jede Zeile erhält eine eigene Kennung von lblRecent1<\/b> bis lblRecent10<\/b> und nennt über getLabel<\/b> die Funktion, die ihren Text liefert. Danach schließt die Definition Gruppe, Spalte, Seite und Bereich wieder ordentlich, und die fertige Zeichenkette geht zurück an Office.<\/p>\n
Das Menüband greifbar halten<\/h2>\n
Sobald Office unsere Oberfläche geladen hat, ruft es die in onLoad<\/b> genannte Funktion auf. Sie tut nur eines, ist aber wichtig: Sie merkt sich das übergebene Menüband in objRibbon<\/b>:<\/p>\n
Public Sub <\/span>customUI_OnLoad(ByVal ribbon As <\/span>IRibbonUI)\r\n    Set<\/span> objRibbon = ribbon\r\nEnd Sub<\/span><\/pre>\n
Über diesen gemerkten Verweis können wir später einzelne Steuerelemente auffrischen lassen – etwa die Beschriftung der Umschalt-Schaltfläche, sobald sich der Zustand ändert, oder die ganze Liste der letzten Sicherungen, wenn eine neue Datei hinzugekommen ist.<\/p>\n
Woher die Liste der letzten Sicherungen kommt<\/h2>\n
Jede der zehn Listenzeilen fragt beim Anzeigen ihre Beschriftung ab. Damit dafür nicht zehn fast gleiche Funktionen nötig sind, reichen sie ihre Nummer an eine gemeinsame Helferin namens GetRecentLabel<\/b> weiter. Diese liest alle Sicherungsdateien im BAS-Ordner ein und ordnet sie nach Datum, sodass die neueste obenauf liegt. Den Kern dieser Sortierung hält Listing 3 fest.<\/p>\n
Private Function <\/span>GetRecentLabel(intPos As Integer<\/span>) As String<\/span>\r\n    Dim <\/span>strFolder As String<\/span>, strFile As String<\/span>, colFiles() As String<\/span>, intCount As Integer<\/span>\r\n    Dim <\/span>i As Integer<\/span>, j As Integer<\/span>, strTemp As String<\/span>, dtTemp As Date<\/span>, dtFile As Date<\/span>\r\n    Dim <\/span>strFullName As String<\/span>, dtMod As Date<\/span>, objVBProject As <\/span>VBIDE.VBProject\r\n    Set<\/span> objVBProject = GetVBProject()\r\n    If <\/span>objVBProject Is Nothing Then<\/span>\r\n        GetRecentLabel = \"\"\r\n        Exit Function<\/span>\r\n    End If<\/span>\r\n    strFolder = Left<\/span>(objVBProject.FileName, InStrRev<\/span>(objVBProject.FileName, \"\\\")) & \"BAS\"\r\n    If <\/span>Dir(strFolder, vbDirectory) = \"\" Then<\/span>\r\n        GetRecentLabel = \"\"\r\n        Exit Function<\/span>\r\n    End If<\/span>\r\n    ReDim colFiles(0)\r\n    intCount = 0\r\n    strFile = Dir(strFolder & \"\\*.bas\")\r\n    Do While<\/span> strFile <> \"\"\r\n        ReDim Preserve colFiles(intCount)\r\n        colFiles(intCount) = strFile\r\n        intCount = intCount + 1\r\n        strFile = Dir()\r\n    Loop<\/span>\r\n    If <\/span>intCount = 0 Then<\/span>\r\n        GetRecentLabel = \"\"\r\n        Exit Function<\/span>\r\n    End If<\/span>\r\n    For i = 0 To intCount - 2\r\n        For j = 0 To intCount - 2 - i\r\n            If <\/span>FileDateTime(strFolder & \"\\\" & colFiles(j)) < FileDateTime(strFolder & \"\\\" & colFiles(j + 1)) Then<\/span>\r\n                strTemp = colFiles(j)\r\n                colFiles(j) = colFiles(j + 1)\r\n                colFiles(j + 1) = strTemp\r\n            End If<\/span>\r\n        Next<\/span> j\r\n    Next<\/span> i\r\n    If <\/span>intPos > intCount Then<\/span>\r\n        GetRecentLabel = \"\"\r\n    Else<\/span>\r\n        strFullName = colFiles(intPos - 1)\r\n        dtMod<\/span> = FileDateTime(strFolder & \"\\\" & strFullName)\r\n        GetRecentLabel = Format(dtMod, \"DD.MM.YY HH:NN:SS\") & \"  \" & strFullName\r\n    End If<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 3: Die Sicherungsdateien werden nach Datum geordnet, die jüngste zuerst<\/span><\/b><\/p>\n
Zum Einsatz kommt hier das Bubble-Sort-Verfahren: Es vergleicht immer zwei benachbarte Dateien und vertauscht sie, falls die ältere vor der jüngeren steht. Nach einigen Durchgängen wandert so die neueste Datei nach oben. Zur gewünschten Position liefert die Funktion anschließend Datum, Uhrzeit und Dateinamen zurück – oder einen leeren Text, falls es noch nicht so viele Sicherungen gibt.<\/p>\n
Das Auswahlfeld für das Intervall<\/h2>\n
Damit das Auswahlfeld beim Öffnen die richtige Stufe hervorhebt, führt der Code die sieben möglichen Werte in einem kleinen Feld. Beim Anzeigen sucht er darin den gespeicherten Wert und meldet dessen Position zurück, sodass genau diese Stufe vorausgewählt erscheint:<\/p>\n
Private <\/span>intervallWerte(6) As Long<\/span>\r\nPrivate Sub <\/span>IntervallWerteInitialisieren()\r\n    intervallWerte(0) = 10 : intervallWerte(1) = 20\r\n    intervallWerte(2) = 30 : intervallWerte(3) = 60\r\n    intervallWerte(4) = 120 : intervallWerte(5) = 300\r\n    intervallWerte(6) = 600\r\nEnd Sub<\/span>\r\nPublic Function <\/span>ddIntervall_GetSelectedItemIndex( _\r\n        ByVal control As <\/span>IRibbonControl) As Integer<\/span>\r\n    IntervallWerteInitialisieren()\r\n    Dim <\/span>intAktuell As Integer<\/span>, i As Integer<\/span>\r\n    intAktuell = IntervallLesen()\r\n    For i = 0 To UBound<\/span>(intervallWerte)\r\n        If <\/span>intervallWerte(i) = intAktuell Then<\/span>\r\n            ddIntervall_GetSelectedItemIndex = i\r\n            Exit Function<\/span>\r\n        End If<\/span>\r\n    Next<\/span> i\r\n    ddIntervall_GetSelectedItemIndex = 5\r\nEnd Function<\/span><\/pre>\n
Wählt der Benutzer eine andere Stufe, tritt ddIntervall_OnAction<\/b> auf den Plan: Die Prozedur schreibt den neuen Wert in die Registry und startet einen laufenden Timer mit dem geänderten Intervall neu, damit die Umstellung sofort greift.<\/p>\n
Ein- und ausschalten über die Schaltfläche<\/h2>\n
Die Umschalt-Schaltfläche kennt zwei Aufgaben. Zum einen liefert sie über btnTimer_GetLabel<\/b> ihre eigene Beschriftung, die je nach Zustand „aktivieren“ oder „deaktivieren“ lautet. Zum anderen schaltet btnTimer_OnAction<\/b> beim Klick zwischen an und aus um und frischt danach die Anzeige auf. Beide Routinen sehen wir hier:<\/p>\n
Public Function <\/span>btnTimer_GetLabel(control As <\/span>_\r\n        IRibbonControl) As String<\/span>\r\n    If <\/span>TimerLaeuft() Then<\/span>\r\n        btnTimer_GetLabel = \"Code-Backup deaktivieren\"\r\n    Else<\/span>\r\n        btnTimer_GetLabel = \"Code-Backup aktivieren\"\r\n    End If<\/span>\r\nEnd Function<\/span>\r\nPublic Sub <\/span>btnTimer_OnAction(control As <\/span>IRibbonControl)\r\n    If <\/span>TimerLaeuft() Then<\/span>\r\n        TimerStoppen()\r\n    Else<\/span>\r\n        TimerStarten()\r\n    End If<\/span>\r\n    objRibbon.Invalidate\r\nEnd Sub<\/span><\/pre>\n
Der Aufruf objRibbon.Invalidate<\/b> am Ende ist der Grund, warum wir uns das Menüband zuvor gemerkt haben: Er weist Office an, die Anzeige neu aufzubauen, sodass die Schaltfläche sofort ihre aktualisierte Beschriftung zeigt.<\/p>\n
Wenn Access das Add-In lädt<\/h2>\n
Sobald Access startet und unser Add-In verbindet, ruft es OnConnection<\/b> auf. Hier richten wir alles ein, was der Helfer später braucht (siehe Listing 4): Wir merken uns Access und den VBA-Editor, hinterlegen einen Verweis auf unsere eigene Instanz im Timer-Modul und legen über CreateToolBar<\/b> die beiden Menüeinträge an.<\/p>\n
Sub <\/span>OnConnection(ByVal Application As Object<\/span>, _\r\n        ByVal ConnectMode As <\/span>ext_ConnectMode, _\r\n        ByVal AddInInst As Object<\/span>, ByRef custom As Variant<\/span>()) _\r\n        Implements IDTExtensibility2.OnConnection\r\n    On Error GoTo<\/span> fehler\r\n    IntervallWerteInitialisieren()\r\n    Set<\/span> objAccess = Application\r\n    Set<\/span> objVBE = objAccess.VBE\r\n    Set<\/span> mdlTimer.addinInstanz = Me\r\n    CreateToolBar()\r\n    Exit Sub<\/span>\r\nFehler:\r\n    MsgBox<\/span>(Err.Number & \" \" & Err.Description & \" \" & Erl, _\r\n        vbOKOnly + vbCr<\/span>itical, \"OnConnection\")\r\nEnd Sub<\/span><\/pre>\n
Listing 4: Beim Verbinden richtet sich das Add-In ein<\/span><\/b><\/p>\n
Der Zeile Set mdlTimer.addinInstanz = Me<\/b> gebührt besondere Aufmerksamkeit – ihre Bedeutung wird beim Timer gleich klar. Die Schnittstelle IDTExtensibility2<\/b> verlangt noch vier weitere Prozeduren: OnDisconnection<\/b>, OnAddInsUpdate<\/b>, OnStartupComplete<\/b> und OnBeginShutdown<\/b>. Die meisten davon bleiben schlicht, doch OnStartupComplete<\/b> hat eine Aufgabe: Es startet den Timer, sobald Access vollständig geladen ist. Beim Beenden räumt OnDisconnection<\/b> wieder auf.<\/p>\n
Zwei Einträge in der Symbolleiste<\/h2>\n
Neben dem Bereich im Datei-Menü setzt das Add-In zwei Einträge in das Add-Ins-Menü des VBA-Editors. Das erledigt CreateToolBar<\/b>, indem es zunächst das vorhandene Menü über seine feste Kennung aufspürt und dann zwei Schaltflächen hinzufügt. Den Ablauf zeigt Listing 5.<\/p>\n
Private Sub <\/span>CreateToolBar()\r\n    Const vbeAddinsMenuID As Long<\/span> = 30038\r\n    Dim <\/span>vbeAddinsMenu As <\/span>CommandBarControl = objVBE.CommandBars.FindControl(msoControlPopup, vbeAddinsMenuID)\r\n    Set<\/span> cbbCodeBackup = vbeAddinsMenu.Controls.Add(Temporary:=True<\/span>)\r\n    With<\/span> cbbCodeBackup\r\n        .Caption = \"amvCodeBackup\"\r\n        Set<\/span> cbbCodeBackupEvents = objVBE.Events.CommandBarEvents(cbbCodeBackup)\r\n    End With<\/span>\r\n    Set<\/span> cbbCodeBackupOptionen = vbeAddinsMenu.Controls.Add(Temporary:=True<\/span>)\r\n    With<\/span> cbbCodeBackupOptionen\r\n        .Caption = \"amvCodeBackup - Intervall setzen\"\r\n        Set<\/span> cbbCodeBackupOptionenEvents = objVBE.Events.CommandBarEvents(cbbCodeBackupOptionen)\r\n    End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 5: CreateToolBar hängt zwei Einträge in das Add-Ins-Menü<\/span><\/b><\/p>\n
Der erste Eintrag dient zum Ein- und Ausschalten, der zweite zum Setzen des Intervalls. Wichtig ist jeweils die letzte Zeile: Erst indem wir das CommandBarEvents<\/b>-Objekt in unseren mit WithEvents<\/b> vereinbarten Variablen ablegen, kann die Klasse später überhaupt auf Klicks reagieren.<\/p>\n
Die Reaktionen auf diese Klicks stehen in zwei Ereignisprozeduren. Die erste schaltet den Timer um, die zweite fragt über eine Eingabebox nach einem neuen Intervall und weist Werte unter zehn Sekunden zurück (siehe Listing 6).<\/p>\n
Private Sub <\/span>cbbCodeBackupEvents_Click(ByVal CommandBarControl As Object<\/span>, handled As Boolean<\/span>, CancelDefault As Boolean<\/span>)\r\n    If <\/span>TimerLaeuft() Then<\/span>\r\n        TimerStoppen()\r\n    Else<\/span>\r\n        TimerStarten()\r\n    End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cbbCodeBackupOptionenEvents_Click(ByVal CommandBarControl As Object<\/span>, _\r\n        handled As Boolean<\/span>, CancelDefault As Boolean<\/span>)\r\n    Dim <\/span>strEingabe As String<\/span>, lngNeu As Long<\/span>\r\n    strEingabe = InputBox(\"Intervall in Sekunden (aktuell: \" & IntervallLesen() & \"s):\", _\r\n        \"amvCodeBackup - Intervall\", IntervallLesen())\r\n    If <\/span>strEingabe = \"\" Then<\/span> Exit Sub<\/span>\r\n    If <\/span>IsNumeric(strEingabe) Then<\/span>\r\n        lngNeu = CLng(strEingabe)\r\n        If <\/span>lngNeu < 10 Then<\/span>\r\n            MsgBox<\/span> \"Mindestintervall: 10 Sekunden.\"\r\n            Exit Sub<\/span>\r\n        End If<\/span>\r\n        IntervallSchreiben lngNeu\r\n        If <\/span>TimerLaeuft() Then<\/span>\r\n            TimerStoppen()\r\n            TimerStarten()\r\n        End If<\/span>\r\n    End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 6: Die beiden Menüeinträge reagieren auf Klicks<\/span><\/b><\/p>\n
So lässt sich das Intervall auf zwei Wegen einstellen – bequem über die festen Stufen im Datei-Menü oder frei per Eingabebox über das Add-Ins-Menü.<\/p>\n
Den Wecker stellen und abschalten<\/h2>\n
Das Stellen des Weckers besorgt eine eigene Prozedur. Sie ruft SetTimer<\/b> mit dem gespeicherten Intervall auf – umgerechnet in Millisekunden, daher die Multiplikation mit 1000 – und merkt sich die zurückgelieferte Kennnummer.<\/p>\n
Das folgende Listing zeigt den Ablauf:<\/p>\n
Private Sub <\/span>TimerStarten()\r\n    On Error GoTo<\/span> Fehler\r\n    lngTimerID = SetTimer(0, 0, IntervallLesen() * 1000, _\r\n        AddressOf mdlTimer.TimerCallback)\r\n    If <\/span>lngTimerID = 0 Then<\/span>\r\n        MsgBox<\/span> \"Timer konnte nicht gestartet werden!\"\r\n    Else<\/span>\r\n        StatusSetzen True<\/span>\r\n    End If<\/span>\r\n    Exit Sub<\/span>\r\nFehler:\r\n    MsgBox<\/span>(Err.Number & \" \" & Err.Description & \" \" & Erl, _\r\n        vbOKOnly + vbCr<\/span>itical, \"TimerStarten\")\r\nEnd Sub<\/span><\/pre>\n
Der vierte Wert im Aufruf, AddressOf mdlTimer.TimerCallback<\/b>, ist der springende Punkt: Er nennt Windows die Prozedur, die beim Auslösen des Weckers aufgerufen werden soll. Das Gegenstück TimerStoppen<\/b> ruft KillTimer<\/b> auf, setzt die Kennnummer zurück und schaltet die Anzeige auf inaktiv; die kurze Funktion TimerLaeuft<\/b> prüft schlicht, ob die Kennnummer ungleich null ist.<\/p>\n
Warum es das Modul mdlTimer braucht<\/h2>\n
Nun zu der angekündigten Feinheit. Windows kann beim Auslösen des Weckers nur eine gewöhnliche Prozedur aufrufen, keine Methode einer Klasse. Deshalb liegt der Empfänger des Weckrufs im Modul mdlTimer<\/b> statt in der Klasse. Listing 7 macht das deutlich.<\/p>\n
Public <\/span>addinInstanz As Object<\/span>\r\n#If Win64 Then\r\nPublic Sub <\/span>TimerCallback(ByVal hWnd As Long<\/span>Ptr, ByVal uMsg As Long<\/span>, ByVal nIDEvent As Long<\/span>Ptr, ByVal dwTime As Long<\/span>)\r\n#Else\r\nPublic Sub <\/span>TimerCallback(ByVal hWnd As Long<\/span>, ByVal uMsg As Long<\/span>, ByVal nIDEvent As Long<\/span>, ByVal dwTime As Long<\/span>)\r\n#End If\r\n    If <\/span>Not<\/span> addinInstanz Is Nothing Then<\/span>\r\n        addinInstanz.BackupNotSavedModules\r\n    End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 7: Der Weckruf landet im Modul und wird an die Klasse weitergereicht<\/span><\/b><\/p>\n
Und hier schließt sich der Kreis zu der Zeile aus OnConnection<\/b>. Weil das Modul selbst nicht weiß, zu welcher Klasse es gehört, haben wir dort einen Verweis auf unsere Instanz in addinInstanz<\/b> abgelegt. Löst der Wecker aus, ruft Windows die Modulprozedur auf, und diese reicht den Auftrag über den gemerkten Verweis an die Sicherungsroutine der Klasse weiter.<\/p>\n
Sichtbar machen, ob der Helfer wacht<\/h2>\n
Ob die automatische Sicherung läuft, soll man auf einen Blick erkennen. Dafür ändert StatusSetzen<\/b> gleich mehrere Dinge: Der Menüeintrag bekommt ein kleines Symbol vorangestellt – einen gefüllten Kreis für aktiv, einen leeren für inaktiv – samt passendem Tooltip. Zusätzlich wandert der Zustand sogar in die Titelleiste von Access, wie Listing 8 andeutet.<\/p>\n
Private Sub <\/span>StatusSetzen(bolAktiv As Boolean<\/span>)\r\n    Dim <\/span>db As <\/span>DAO.Database\r\n    Dim <\/span>strDB As String<\/span>\r\n    On Error GoTo<\/span> Fehler\r\n    If <\/span>Not<\/span> cbbCodeBackup Is Nothing Then<\/span>\r\n        Set<\/span> db = objAccess.CurrentDb\r\n        On Error Resume Next<\/span>\r\n        strDB = Mid<\/span>(db.Name, InStrRev<\/span>(db.Name, \"\\\") + 1)\r\n        If <\/span>Len<\/span>(strDB) = 0 Then<\/span>\r\n            Exit Sub<\/span>\r\n        End If<\/span>\r\n        If <\/span>bolAktiv = True<\/span> Then<\/span>\r\n            cbbCodeBackup.Caption = \"• amvCodeBackup\"\r\n            cbbCodeBackup.TooltipText = \"Aktiv - Intervall: \" & IntervallLesen() & \"s\"\r\n            Call<\/span> AnwendungstitelAendern(db, \"? \" & strDB & \" - Backup aktiv (\" & IntervallLesen() & \"s) \" & Now)\r\n        Else<\/span>\r\n            cbbCodeBackup.Caption = \"o amvCodeBackup\"\r\n            cbbCodeBackup.TooltipText = \"Inaktiv\"\r\n            Call<\/span> AnwendungstitelAendern(db, \"? \" & strDB & \" - Backup inaktiv\")\r\n        End If<\/span>\r\n        Set<\/span> db = Nothing\r\n    End If<\/span>\r\n    If <\/span>Not<\/span> objRibbon Is Nothing Then<\/span>\r\n        objRibbon.InvalidateControl \"btnTimer\"\r\n    End If<\/span>\r\n    Exit Sub<\/span>\r\nFehler:\r\n    MsgBox<\/span> Err.Number & \" \" & Err.Description & \" \" & Erl, vbOKOnly + vbCr<\/span>itical, \"StatusSetzen\"\r\nEnd Sub<\/span><\/pre>\n
Listing 8: StatusSetzen aktualisiert Beschriftung, Tooltip und Fenstertitel<\/span><\/b><\/p>\n
Das Ändern des Fensternamens übernimmt AnwendungstitelAendern<\/b>. Die Prozedur setzt die Eigenschaft AppTitle<\/b> der Datenbank – und legt sie zuvor an, falls es sie noch nicht gibt, denn nicht jede Datenbank bringt diese Eigenschaft von Haus aus mit. Ein abschließendes RefreshTitleBar<\/b> sorgt dafür, dass die Änderung sofort sichtbar wird.<\/p>\n
Das Herzstück: nur Änderungen sichern<\/h2>\n
Jetzt zum Kern des Add-Ins – jener Prozedur, die der Wecker regelmäßig anstoßt. Sie geht alle Bestandteile des Projekts durch und interessiert sich nur für die seit dem letzten Speichern geänderten; das verrät die Eigenschaft Saved<\/b>. Für jedes solche Modul berechnet sie einen Fingerabdruck und vergleicht ihn mit dem zuletzt gemerkten. Nur bei einem Unterschied entsteht wirklich eine neue Datei, wie in Listing 9 zu sehen ist.<\/p>\n
Public Sub <\/span>BackupNotSavedModules()\r\n    Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent, objVBProject As <\/span>VBIDE.VBProject, strModulename As String<\/span>\r\n    Dim <\/span>strModuleFolder As String<\/span>, strModulePath As String<\/span>, strAccessName As String<\/span>, strHashAktuell As String<\/span>\r\n    Dim <\/span>bolEtwasGesichert As Boolean<\/span>    \r\n    If <\/span>dicHashes Is Nothing Then<\/span>\r\n        Set<\/span> dicHashes = CreateObject(\"Scripting.Dictionary\")\r\n    End If<\/span>\r\n    Set<\/span> objVBProject = GetVBProject()\r\n    If <\/span>objVBProject Is Nothing Then<\/span> Exit Sub<\/span>\r\n    strModuleFolder = Left<\/span>(objVBProject.FileName, InStrRev<\/span>(objVBProject.FileName, \"\\\")) & \"BAS\"\r\n    On Error Resume Next<\/span>\r\n    MkDir strModuleFolder\r\n    On Error GoTo<\/span> 0\r\n    bolEtwasGesichert = False<\/span>\r\n    For Each objVBComponent In objVBProject.VBComponents\r\n        If <\/span>objVBComponent.Saved = False<\/span> Then<\/span>\r\n            strHashAktuell = ModulHash(objVBComponent)\r\n            If <\/span>Not<\/span> dicHashes.Exists(objVBComponent.Name) Or dicHashes(objVBComponent.Name) <> strHashAktuell Then<\/span>\r\n                strModulename = objVBComponent.Name\r\n                strModulePath = strModuleFolder & \"\\\" & strModulename & \"_\" & Format(Now, \"YYYYMMDD_HHNNSS\") & \".bas\"\r\n                Select Case objVBComponent.Type\r\n                    Case <\/span>vbext_ct_StdModule, vbext_ct_ClassModule\r\n                        objAccess.SaveAsText acModule, strModulename, strModulePath\r\n                    Case <\/span>vbext_ct_Document\r\n                        strAccessName = Mid<\/span>(strModulename, InStr<\/span>(strModulename, \"_\") + 1)\r\n                        If <\/span>Left<\/span>(strModulename, 5) = \"Form_\" Then<\/span>\r\n                            objAccess.SaveAsText acForm, strAccessName, strModulePath\r\n                        Else<\/span>If Left<\/span>(strModulename, 7) = \"Report_\" Then\r\n                            objAccess.SaveAsText acReport, strAccessName, strModulePath\r\n                        End If<\/span>\r\n                End Select<\/span>\r\n                dicHashes(objVBComponent.Name) = strHashAktuell\r\n                bolEtwasGesichert = True<\/span>\r\n                If <\/span>Not<\/span> cbbCodeBackup Is Nothing Then<\/span>\r\n                    cbbCodeBackup.TooltipText = \"Aktiv - letzter Backup: \" & strModulename & \" (\" _\r\n                        & Format(Now, \"HH:NN:SS\") & \")\"\r\n                End If<\/span>\r\n            End If<\/span>\r\n        End If<\/span>\r\n    Next<\/span> objVBComponent\r\n    If <\/span>bolEtwasGesichert And Not<\/span> objRibbon Is Nothing Then<\/span>\r\n        objRibbon.Invalidate\r\n    End If    \r\n    Call<\/span> StatusSetzen(True<\/span>)    \r\nEnd Sub<\/span><\/pre>\n
Listing 9: Nur tatsächlich geänderte Module werden geschrieben<\/span><\/b><\/p>\n
Der Dateiname setzt sich aus dem Modulnamen und dem aktuellen Zeitpunkt zusammen. Dadurch entsteht bei jeder Sicherung eine neue Datei, und ältere Fassungen bleiben erhalten – praktisch, wenn man einmal zu einem früheren Stand zurückkehren möchte. Je nach Art des Bestandteils wählt der Code das richtige Verfahren: Standard- und Klassenmodule schreibt er direkt weg, bei Formularen und Berichten löst er zuvor den eigentlichen Namen aus der Bezeichnung heraus. Zuletzt merkt er sich den neuen Fingerabdruck, damit dasselbe Modul nicht schon beim nächsten Durchgang erneut gesichert wird.<\/p>\n
Der Fingerabdruck eines Moduls<\/h2>\n
Bleibt die Frage, wie dieser Fingerabdruck entsteht. ModulHash<\/b> liest den gesamten Code eines Moduls und berechnet daraus eine kurze Prüfsumme nach dem MD5-Verfahren. Man kann sie sich als Zahlencode vorstellen, der schon bei der kleinsten Textänderung völlig anders ausfällt – ideal, um Änderungen zu erkennen. Den Kern zeigt Listing 10.<\/p>\n
Private Function <\/span>ModulHash(objComp As <\/span>VBIDE.VBComponent) As String<\/span>\r\n    On Error GoTo<\/span> Fallback\r\n    Dim <\/span>strCode As String<\/span>\r\n    Dim <\/span>bytData() As Byte<\/span>\r\n    Dim <\/span>objMD5 As Object<\/span>\r\n    Dim <\/span>bytHash() As Byte<\/span>\r\n    Dim <\/span>i As Integer<\/span>\r\n    Dim <\/span>strHex As String<\/span>\r\n    Dim <\/span>objStream As Object<\/span>\r\n    With<\/span> objComp.CodeModule\r\n        If <\/span>.CountOfLines > 0 Then<\/span>\r\n            strCode = .Lines(1, .CountOfLines)\r\n        End If<\/span>\r\n    End With<\/span>\r\n    Set<\/span> objStream = CreateObject(\"ADODB.Stream\")\r\n    objStream.Open\r\n    objStream.Charset = \"utf-8\"\r\n    objStream.WriteText strCode\r\n    objStream.Position = 0\r\n    objStream.Type = 1\r\n    bytData = objStream.Read\r\n    objStream.Close\r\n    Set<\/span> objMD5 = CreateObject(\"System.Security.Cryptography.MD5CryptoServiceProvider\")\r\n    bytHash = objMD5.ComputeHash_2(bytData)\r\n    For i = 0 To UBound<\/span>(bytHash)\r\n        strHex = strHex & Right<\/span>(\"00\" & Hex(bytHash(i)), 2)\r\n    Next<\/span> i\r\n    ModulHash = strHex\r\n    Exit Function<\/span>\r\nFallback:\r\n    ModulHash = CStr(Len<\/span>(strCode)) & \"_\" & CStr(objComp.CodeModule.CountOfLines)\r\nEnd Function<\/span><\/pre>\n
Listing 10: ModulHash bildet eine Prüfsumme über den Modulcode<\/span><\/b><\/p>\n
Der Umweg über ein ADODB.Stream<\/b>-Objekt dient allein dazu, den Text sauber in eine Folge von Bytes zu verwandeln, denn genau die erwartet die MD5-Berechnung. Geht dabei einmal etwas schief, greift ein Ersatz, der aus der Länge des Codes und der Zeilenzahl eine einfachere Kennung bildet – weniger genau, aber für unseren Zweck völlig ausreichend.<\/p>\n
Das Add-In bekannt machen<\/h2>\n
Damit Access den Helfer beim Start überhaupt findet, muss er in der Registry stehen. Darum kümmert sich das Modul DllRegistration<\/b>. Am Anfang setzt es aus dem Projekt- und Klassennamen die Registry-Pfade zusammen:<\/p>\n
Const AddinProjectName As String<\/span> = _\r\n    VBA.Compilation.CurrentProjectName\r\nConst AddinClassName As String<\/span> = \"amvCodeBackup\"\r\nConst AddinQualifiedClassName As String<\/span> = _\r\n    AddinProjectName & \".\" & AddinClassName\r\nConst RootRegistryFolder As String<\/span> = _\r\n    \"HKCU\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\\" & _\r\n    AddinQualifiedClassName & \"\\\"<\/pre>\n
Der Pfad zeigt in den Zweig des aktuellen Benutzers – Abkürzung HKCU<\/b> – in den Bereich der Access-Add-Ins. Weil wir dort und nicht im systemweiten Zweig schreiben, sind später keine Administratorrechte nötig. Das Eintragen selbst übernimmt DllRegisterServer<\/b> (siehe Listing 11).<\/p>\n
Public Function <\/span>DllRegisterServer() As Boolean<\/span>\r\n    On Error GoTo<\/span> RegError\r\n    Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n    wscript.RegWrite RootRegistryFolder & \"FriendlyName\", AddinProjectName, \"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\nRegError:\r\n    MsgBox<\/span> \"DllRegisterServer -- An error occured trying to write to the system registry:\" & vbCrLf<\/span> & _\r\n        Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n    Return False<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 11: DllRegisterServer legt die Registry-Einträge an<\/span><\/b><\/p>\n
Die Funktion schreibt drei Werte. FriendlyName<\/b> und Description<\/b> erhalten den Projektnamen, und LoadBehavior<\/b> bekommt die 3<\/b> – dieser Wert weist Access an, das Add-In gleich beim Start zu laden. Das Gegenstück DllUnregisterServer<\/b> löscht dieselben Einträge spiegelbildlich wieder, wie Listing 12 zeigt.<\/p>\n
Public Function <\/span>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\nRegError:\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\nEnd Function<\/span><\/pre>\n
Listing 12: DllUnregisterServer entfernt die Einträge wieder<\/span><\/b><\/p>\n
Die Namen DllRegisterServer<\/b> und DllUnregisterServer<\/b> sind nicht frei wählbar, sondern von COM fest vorgegeben. twinBASIC ruft sie beim Registrieren und Aufheben automatisch auf; auf einem fremden Rechner übernimmt später das Windows-Werkzeug regsvr32<\/b> dieselbe Aufgabe. Wichtig ist dabei nur, dass die Bitness von Werkzeug und DLL zusammenpasst.<\/p>\n
Wiederherstellen gesicherter Elemente<\/h2>\n
Um Formlare oder Berichte wiederherzustellen, verwenden wir die LoadFromText<\/b>-Methode beispielsweise wie folgt:<\/p>\n
LoadFromText acform, \"frmModulSpeichern\", currentproject.Path & \"\\BAS\\Form_frmModulSpeichern_20260704_200253.bas\"<\/pre>\n
Zum Wiederherstellen eines Moduls ziehen wir die gesicherte Datei einfach in den Objekt-Explorer des VBA-Editors.<\/p>\n
Zusammenfassung und Ausblick<\/h2>\n
Aus überschaubaren Bausteinen ist ein nützlicher Helfer geworden. Das COM-Add-In sichert im Hintergrund in einstellbaren Abständen alle geänderten Module in einzelne Textdateien – ohne Zutun des Entwicklers und dank des Fingerabdruck-Vergleichs nur dann, wenn sich wirklich etwas getan hat.<\/p>\n
Mit der Einstellung des Intervalls zwischen den Sicherungen wählt man zwischen hoher Anzahl Backups und damit einer größeren Sicherheit bei Access-Abstürzen und weniger Meldungen, wenn man Änderungen an Formular- oder Berichtsmodulen durchgeführt hat.<\/p>\n
Hier taucht, wie oben bereits beschrieben, jeweils eine Meldung auf, weil ungespeicherte Formulare nicht gesichert werden können.<\/p>\n
Man könnte nun argumentieren, dass eine Sicherung von Formularen und Berichten nicht mehr nötig ist, wenn man diese ohnehin vor der Sicherung speichern muss.<\/p>\n
Allerdings erhalten wir damit einen bisher noch nicht erwähnten Vorteil: Wir sichern so den Zustand aller geänderten Module in einzelnen Dateien. So können wir, wenn keine andere Versionsverwaltung im Einsatz ist, auch Zwischenstände wiederherstellen, wenn wir beim Entwickeln einmal in eine Sackgasse gelaufen sind. Bild 4 zeigt die im BAS-Ordner gesicherten Versionen verschiedener Module.<\/p>\n
\"Gesicherte<\/p>\n
Bild 4: Gesicherte Formulare und Module im Windows Explorer<\/span><\/b><\/p>\n
Zwei Kniffe bleiben besonders im Gedächtnis. Da ist der Umweg des Weckrufs über ein eigenes Modul, weil Windows beim Timer keine Klassenmethode direkt ansprechen kann. Und da ist der Fingerabdruck per MD5, der unnötige Sicherungen unveränderter Module verhindert. Wer möchte, baut den Helfer leicht aus – etwa um eine Obergrenze für die Zahl gespeicherter Fassungen je Modul oder um eine Schaltfläche, die den BAS-Ordner direkt öffnet.<\/p>\n
Die gesicherten Module müssen momentan noch manuell hinzugefügt werden – man könnte noch eine Möglichkeit schaffen, diese übersichtlich darzustellen und sie zum Wiederherstellen per Mausklick einfach anzuklicken.<\/p>\n","protected":false},"excerpt":{"rendered":"
Wer viel in VBA programmiert, kennt den Schreck: Ein Absturz von Access, und die Arbeit der letzten halben Stunde ist weg. Natürlich kann man von Hand speichern – aber genau das vergisst man im Eifer des Gefechts. In diesem Beitrag bauen wir uns einen fleißigen Helfer, der uns diese Sorge abnimmt: ein COM-Add-In für den Access-Entwickler, das in einstellbaren Abständen alle geänderten Formulare, Berichte und Module automatisch in einzelne Textdateien sichert. So haben wir immer eine frische Kopie unseres Codes zur Hand, ganz ohne daran zu denken.<\/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":[662026,66042026,44000027],"tags":[],"class_list":["post-55001612","post","type-post","status-publish","format-standard","hentry","category-662026","category-66042026","category-Loesungen"],"yoast_head":"\nVBA-Module regelmäßig sichern per COM-Add-In - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"VBA-Module regelmäßig sichern per COM-Add-In\" \/>\n<meta property=\"og:description\" content=\"Wer viel in VBA programmiert, kennt den Schreck: Ein Absturz von Access, und die Arbeit der letzten halben Stunde ist weg. Natürlich kann man von Hand speichern - aber genau das vergisst man im Eifer des Gefechts. In diesem Beitrag bauen wir uns einen fleißigen Helfer, der uns diese Sorge abnimmt: ein COM-Add-In für den Access-Entwickler, das in einstellbaren Abständen alle geänderten Formulare, Berichte und Module automatisch in einzelne Textdateien sichert. So haben wir immer eine frische Kopie unseres Codes zur Hand, ganz ohne daran zu denken.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-05T11:03:27+00:00\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"25\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"VBA-Module regelmäßig sichern per COM-Add-In\",\"datePublished\":\"2026-07-05T11:03:27+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/\"},\"wordCount\":3314,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"articleSection\":[\"2026\",\"4\\\/2026\",\"L\u00f6sungen\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/\",\"name\":\"VBA-Module regelmäßig sichern per COM-Add-In - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"datePublished\":\"2026-07-05T11:03:27+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/VBAModule_regelmaessig_sichern_per_COMAddIn\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"VBA-Module regelmäßig sichern per COM-Add-In\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"VBA-Module regelmäßig sichern per COM-Add-In - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/","og_locale":"de_DE","og_type":"article","og_title":"VBA-Module regelmäßig sichern per COM-Add-In","og_description":"Wer viel in VBA programmiert, kennt den Schreck: Ein Absturz von Access, und die Arbeit der letzten halben Stunde ist weg. Natürlich kann man von Hand speichern - aber genau das vergisst man im Eifer des Gefechts. In diesem Beitrag bauen wir uns einen fleißigen Helfer, der uns diese Sorge abnimmt: ein COM-Add-In für den Access-Entwickler, das in einstellbaren Abständen alle geänderten Formulare, Berichte und Module automatisch in einzelne Textdateien sichert. So haben wir immer eine frische Kopie unseres Codes zur Hand, ganz ohne daran zu denken.","og_url":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/","og_site_name":"Access im Unternehmen","article_published_time":"2026-07-05T11:03:27+00:00","author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"25\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"VBA-Module regelmäßig sichern per COM-Add-In","datePublished":"2026-07-05T11:03:27+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/"},"wordCount":3314,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"articleSection":["2026","4\/2026","L\u00f6sungen"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/","url":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/","name":"VBA-Module regelmäßig sichern per COM-Add-In - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"datePublished":"2026-07-05T11:03:27+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/VBAModule_regelmaessig_sichern_per_COMAddIn\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"VBA-Module regelmäßig sichern per COM-Add-In"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55001612","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55001612"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55001612\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55001612"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55001612"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55001612"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}