<\/p>\n
Ein Kunde hatte die Anforderung, dass das Backend grundsätzlich auf dem Server liegen sollte und der Benutzer vom Frontend auf seinem Rechner per Netzwerk vom Homeoffice darauf zugreift. Wegen instabiler Internetverbindung soll das Backend aber während der Bearbeitung besser auf den lokalen Rechner kopiert werden und nach dem Schließen der Anwendung wieder zurück auf den Server. Wie man dies realisieren kann und was dabei zu beachten ist, zeigen wir in diesem Beitrag.<\/b><\/p>\n
Voraussetzung<\/b><\/p>\n
Wir gehen an dieser Stelle davon aus, dass das Verzeichnis, in dem sich das Backend auf dem Server befindet, als Netzlaufwerk in den lokalen Rechner eingebunden ist, sodass das Backend mit den üblichen VBA-Methoden zum Kopieren von Dateien auf den lokalen Rechner und zurück zum Server kopiert werden kann.<\/p>\n
Planung<\/b><\/p>\n
Naiv betrachtet könnte man die Aufgabe herunterbrechen in folgende Schritte:<\/p>\n
Das setzt jedoch voraus, dass das Fronted immer ordnungsgemäß geschlossen wird und niemals abstürzt. Wenn das Frontend einmal abstürzt, würde es beim erneuten Start das Backend erneut auf den lokalen Rechner kopieren und die Tabellen einbinden. Das wird zum Problem, sobald der Benutzer vor dem Absturz bereits Daten geändert hat.<\/p>\n
Beim Starten wird nämlich dann die alte Version des Backends vom Server geladen und eingebunden und die vor dem Absturz durchgeführten Änderungen sind nicht mehr verfügbar.<\/p>\n
Dem müssen wir Rechnung tragen, indem wir beispielsweise in einer Optionen-Tabelle festhalten, wann das Backend vom Server auf den lokalen Rechner kopiert wurde und umgekehrt.<\/p>\n
Dann können wir beim Start der Anwendung prüfen, ob das letzte Kopieren auf den Server vor oder nach dem letzten Kopieren vom Server auf den lokalen Rechner stattgefunden hat und damit ermitteln, ob die Anwendung beendet wurde, ohne dass das Backend auf den Server kopiert wurde.<\/p>\n
Erster Schritt: Backend erstellen<\/b><\/p>\n
Sollten Sie eine solche Lösung ausgehend von einer Datenbank erstellen, deren Tabellen und Benutzeroberfläche noch in einer einzigen Datenbankdatei gespeichert sind, müssen Sie zunächst ein Backend erstellen und die Tabellen, die später auf dem Server liegen sollen, in das Backend verschieben. Danach löschen Sie diese Tabellen aus dem Frontend und erstellen entsprechende Verknüpfungen auf die Tabellen des Backends. Als Beispiel verwenden wir die Datenbank zum flexiblen Verwalten von Adressen aus dem Beitrag Flexible Adressen <\/b>(www.access-im-unternehmen.de\/1214<\/b>). Diese enthält eine überschaubare Anzahl von Tabellen.<\/p>\n
Aufteilen der Datenbank<\/b><\/p>\n
Das Aufteilen der Datenbank lassen wir bequem von dem dafür vorgesehenen Assistenten erledigen. Diesen starten Sie über den Ribbon-Befehl Datenbanktools|Daten verschieben|Access-Datenbank <\/b>(siehe Bild 1).<\/p>\n
![\"Aufteilen](\"..\/fileadmin\/_temp_\/2019_06\/pic_1216_001.png\")
<\/p>\n
Bild 1: Aufteilen einer Datenbank<\/span><\/b><\/p>\n Auf der ersten Seite des so gestarteten Assistenten klicken Sie auf die Schaltfläche Datenbank aufteilen <\/b>und wählen im nun erscheinenden Dialog Back-End-Datenbank erstellen <\/b>den Pfad zu der zu erstellenden Backend-Datenbank aus. Wir geben hier einfach den Namen der aufzuteilenden Datenbank mit dem Suffix _BE <\/b>an, also BackendKopieren_BE.accdb <\/b>(siehe Bild 2).<\/p>\n Bild 2: Auswahl der Zieldatenbank<\/span><\/b><\/p>\n Bei der hier verwendeten Anzahl Tabellen schließt der Assistent den Vorgang recht zügig ab.<\/p>\n Die Änderungen im Frontend sind überschaubar: Statt der bisher vorhandenen lokalen Tabellen finden sich im Navigationsbereich nun die gleichen Tabellen, allerdings mit dem Verknüpfungssymbol (siehe Bild 3).<\/p>\n Bild 3: Das Frontend nach der Aufteilung<\/span><\/b><\/p>\n Wenn Sie diese öffnen, zeigen Sie die Daten allerdings genau so an, als ob Sie eine lokale Tabelle verwenden. Auch das Bearbeiten der enthaltenen Daten geschieht wie gewohnt.<\/p>\n Verknüpfungen löschen und neu erstellen oder aktualisieren<\/b><\/p>\n Nun stellt sich die Frage: Wollen wir die Verknüpfungen löschen, bevor wir die Backend-Datenbank, die ja aktuell im gleichen Verzeichnis wie die Frontend-Datenbank liegt, auf den Server verschieben und diese neu anlegen, wenn das Backend beim nächsten Öffnen des Datenbankfrontends vom Server geholt wird Oder reicht es aus, die Verknüpfungen zu aktualisieren Wenn Sie das Frontend immer vom gleichen Verzeichnis aus starten und sich das Backend ebenfalls immer in diesem Verzeichnis befindet, ist das grundsätzlich nicht nötig, wenn nur das Backend ausgetauscht wird. Allerdings kann es ja einmal vorkommen, dass der Benutzer die Frontend-Datenbank auf einen anderen Rechner kopiert oder sich der Verzeichnisname ändert. Dann müssen die Verknüpfungen doch aktualisiert werden.<\/p>\n Wir begnügen uns mit dem Aktualisieren aller in der Frontend-Datenbank enthaltenen Verknüpfungen – so kann man auch einmal eine neue Tabelle zum Backend hinzufügen und braucht diese nur manuell zu verknüpfen, damit diese Verknüpfung bei folgenden Starts der Anwendung in das Aktualisieren aller vorhandenen Verknüpfungen integriert wird.<\/p>\n Verknüpfungen per VBA aktualisieren<\/b><\/p>\n Das Aktualisieren der verknüpften Tabellen erledigen wir mit der Prozedur aus Listing 1. Diese deklariert ein Database<\/b>– und ein TableDef<\/b>-Objekt und weist der Database<\/b>-Variablen db <\/b>das Database<\/b>-Objekt der aktuellen Datenbank zu. Dann durchläuft es alle TableDef<\/b>-Objekte der Auflistung TableDefs <\/b>des Database<\/b>-Objekts und referenziert diese jeweils mit der Variablen tdf<\/b>.<\/p>\n Listing 1: Verknüpfungen aktualisieren<\/span><\/b><\/p>\n Dabei prüft sie zunächst anhand der Eigenschaft Connect<\/b> des TableDef<\/b>-Objekts, ob es sich bei der Tabelle um eine lokale oder eine verknüpfte Tabelle handelt. Enthält diese Eigenschaft einen Wert, handelt es sich um ein verknüpftes Objekt. In diesem Fall stellen wir die Eigenschaft auf einen Wert ein, der aus ;DATABASE=<\/b>, dem Pfad der Frontend-Datenbank, einem Backslash sowie dem angenommenen Namen der Backend-Datenbank besteht, also zum Beispiel folgenden Ausdruck:<\/p>\n Danach aktualisieren wir die Verknüpfung mit der RefreshLink<\/b>-Methode.<\/p>\n Aktualisieren der Verknüpfungen testen<\/b><\/p>\n Um die Verknüpfungen nach der Aktualisierung zu testen, verschieben Sie die beiden Datenbanken beispielsweise in ein Unterverzeichnis namens Test<\/b>. Wenn Sie dann die Frontend-Datenbank öffnen und versuchen, eine der Tabellen über die Verknüpfung zu öffnen, erhalten Sie die Fehlermeldung aus Bild 4. Logisch: Die Verknüpfugn zeigt über die Connect<\/b>-Eigenschaft noch auf den alten Speicherort der Backend-Datenbank.<\/p>\n Bild 4: Fehler beim Versuch, eine verknüpfte Tabelle nach dem Verschieben zu öffnen<\/span><\/b><\/p>\n Erst nachdem Sie nun die Prozedur VerknuepfungenAktualisieren <\/b>aufrufen, funktioniert das Öffnen der verknüpften Tabellen wieder.<\/p>\n Übrigens reicht es nicht aus, Frontend und Backend einfach nur in ein anderes Verzeichnis zu kopieren, um den Fehler beim Zugriff auf eine der verknüpften Tabellen auszulösen. Genau genommen resultieren aus dieser Aktion oft Verwirrungen, weil man über das Frontend vermeintlich Daten der verknüpften Tabellen im neuen Verzeichnis vornimmt. Tatsächlich greift das Frontend aber, wenn Sie die Datenbankdateien nur kopieren und nicht verschieben (beziehungsweise die Datenbankdateien am alten Speicherort löschen) noch auf das Backend im alten Speicherort zu.<\/p>\n Optionen für das Kopieren<\/b><\/p>\n Nun wollen wir das Backend bei jedem Öffnen der Anwendung neu vom Server in das lokale Verzeichnis kopieren und die Verknüpfung aktualisieren. Dazu muss die entsprechende Prozedur wissen, unter welchem Pfad sie auf die auf dem Server liegende Datei zugreifen kann. Dazu wollen wir eine Optionen-Tabelle namens tblOptionen <\/b>anlegen. Neben einem Feld namens Backendpfad<\/b> wollen wir noch weitere Informationen in dieser Tabelle speichern. Wir müssen nämlich in irgendeiner Form festhalten, ob das Backend zuletzt vom Server auf das lokale Verzeichnis oder vom lokalen Verzeichnis auf den Server kopiert wurde.<\/p>\n Wenn das Backend zuletzt vom lokalen Verzeichnis auf den Server kopiert wurde, ist das offensichtlich beim vorherigen Schließen der Anwendung geschehen. Wenn hingegen beim Öffnen des Frontends die Information vorliegt, dass der letzte Kopiervorgang vom Server zum lokalen Verzeichnis erfolgte, dann wurde das Frontend bei der letzten Verwendung offensichtlich nicht korrekt geschlossen.<\/p>\n In diesem Fall wollen wir prüfen, ob das auf dem Server oder das im lokalen Verzeichnis gespeicherte Backend ein aktuelleres Bearbeitungsdatum hat. Ist das Backend im lokalen Verzeichnis neuer, soll der Benutzer gefragt werden, ob das neuere Backend weiter genutzt werden soll oder ob das ältere Backend vom Server über das vorhandene Backend kopiert werden soll.<\/p>\n Wie speichern wir diese Information ab Wir könnten zwei Felder definieren, die wir etwa ZuletztVomServerKopiert <\/b>und ZuletztZumServerVerschoben <\/b>nennen und die den Datentyp Datum\/Uhrzeit<\/b> erhalten. Oder wir verwenden einfach ein Boolean<\/b>-Feld etwa namens ZuletztVomServerKopiert<\/b>. Wenn es den Wert True <\/b>enthält, wurde das Backend zuletzt vom Server in das lokale Verzeichnis kopiert, im Falle von False <\/b>wurde es vom lokalen Verzeichnis zum Server verschoben.<\/p>\n <\/p>\n Die Datumsangaben zu speichern, ist schon interessant, da wir dem Benutzer im Falle eines unterwarteten Schließens zusätzliche Informationen liefern können, wann das Backend zuletzt wohin kopiert oder verschoben wurde – also legen wir zwei Felder namens ZuletztVomServerKopiert <\/b>und ZuletztZumServerVerschoben <\/b>an.<\/p>\n Die Tabelle tblOptionen<\/b> sieht damit wie in Bild 5 aus.<\/p>\n Bild 5: Die Tabelle mit den Optionen der Anwendung<\/span><\/b><\/p>\n Verwalten der Optionen der Anwendung<\/b><\/p>\n Um den Pfad zur Backenddatenbank festlegen zu können, fügen wir der Datenbank ein Formular namens frmOptionen <\/b>hinzu, das wir über die Eigenschaft Datensatzquelle <\/b>an die Tabelle tblOptionen <\/b>binden. Wir ziehen alle Felder dieser Tabelle aus der Feldliste in den Detailbereich des Formularentwurfs. Das Textfeld BackendPfad <\/b>benennen wir in txtBackendPfad<\/b> um. Neben diesem Textfeld platzieren wir eine Schaltfläche namens cmdAuswaehlen<\/b>, unter den drei Textfeldern eine weitere Schaltfläche namens cmdOK<\/b>. Das Formular sieht dann wie in Bild 6 aus. Die beiden Textfelder, die an die Felder ZuletztVomServerKopiert <\/b>und ZuletztZumServerVerschoben <\/b>gebunden sind, soll der Benutzer nicht bearbeiten können. Daher stellen wir für beide Textfelder die Eigenschaften Aktiviert <\/b>auf Nein <\/b>und Gesperrt <\/b>auf Ja <\/b>ein.<\/p>\n Bild 6: Formular zum Bearbeiten und Ansehen der Optionen<\/span><\/b><\/p>\n Für die Schaltfläche cmdAuswaehlen <\/b>hinterlegen wir die folgende Ereignisprozedur:<\/p>\n Diese öffnet mit der Funktion OpenFileName <\/b>aus dem Modul mdlTools <\/b>den Dateiauswahl<\/b>-Dialog und schreibt den Pfad zu der vom Benutzer ausgewählten Datenbankdatei in das Textfeld txtBackendpfad<\/b>.<\/p>\n Als Standardpfad beim Anzeigen des Dialogs soll der Pfad zu der aktuell im Textfeld ausgewählten Datei angezeigt werden, den wir zuvor mit geeigneten Zeichenkettenfunktionen ermitteln.<\/p>\n Die Schaltfläche cmdOK <\/b>soll das Formular schlicht schließen:<\/p>\n Damit das Formular keine Möglichkeit zum Wechseln des Datensatzes bietet – die Tabelle tblOptionen<\/b> soll ja nur einen Satz von Optionen enthalten -, stellen wir die Eigenschaften Navigationsschaltflächen <\/b>auf Nein <\/b>und Zyklus <\/b>auf Aktueller Datensatz <\/b>ein. Außerdem legen wir die Werte der Eigenschaften Datensatzmarkierer <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>fest.<\/p>\n Backend vom Server holen<\/b><\/p>\n Die folgende Prozedur soll prüfen, ob das Backend vom Server in den Ordner der lokalen Datenbank kopiert werden soll.<\/p>\n Das ist unter folgenden Bedingungen der Fall:<\/p>\n In allen anderen Fällen gehen wir davon aus, dass die Anwendung nicht ordnungsgemäß geschlossen wurde und fragen den Benutzer, ob er die Version vom Server tatsächlich über die aktuell auf dem lokalen Verzeichnis gespeicherte Version überspielen soll.<\/p>\n Das Kopieren des Backends vom Server in das Verzeichnis des Frontends erledigt die Funktion BackendHolen<\/b> aus Listing 2. Diese Funktion verwendet wieder eine Objektvariable namens db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt. Außerdem liest sie die Daten der Tabelle tblOptionen <\/b>in ein Recordset namens rst <\/b>ein.<\/p>\n Listing 2: Backend vom Server in das Verzeichnis des Frontends kopieren<\/span><\/b><\/p>\n Sie prüft dann zunächst, ob der Wert des Feldes ZuletztVomServerKopiert <\/b>größer ist als der des Feldes ZuletztZumServerVerschoben<\/b>. Damit hier kein Fehler wegen eines Nullwertes ausgelöst wird, ersetzen wir diese gegebenenfalls mit der Nz<\/b>-Funktion durch den Wert 0<\/b>. Ist ZuletztVomServerKopiert <\/b>größer, wurde die Backend-Datenbank seit dem letzten Kopieren nicht wieder zum Server zurückgeschrieben. In diesem Fall soll die folgende Meldung den Benutzer darauf aufmerksam machen und fragen, ob dieser die Backend-Datenbank vom Server tatsächlich über die Version im lokalen Verzeichnis schreiben lassen möchte. Falls ja, wird die Variable bolBackendHolen <\/b>auf den Wert True <\/b>eingestellt. Anderenfalls, also falls ZuletztZumServerVerschoben <\/b>größer ist, wird bolBackendHolen <\/b>ebenfalls auf True <\/b>eingestellt.<\/p>\n Hat bolBackendHolen <\/b>danach den Wert True<\/b>, wird die vorhandene Backend-Datenbank im lokalen Verzeichnis mit der Kill<\/b>-Anweisung gelöscht und die Version vom Server mit der FileCopy<\/b>-Anweisung in das lokale Verzeichnis kopiert. Außerdem ruft die Prozedur dann noch die Routine VerknuepfungenAktualisieren <\/b>auf, um die Verknüpfungen zu aktualisieren. Schließlich versetzt sie das Recordset rst <\/b>mit der Edit<\/b>-Methode in den Bearbeitungszustand und stellt dabei den Wert des Feldes ZuletztVomServerKopiert <\/b>auf das aktuelle Datum und die aktuelle Uhrzeit ein. Damit der neue Zustand des Recordsets in die Tabelle übertragen wird, ruft die Funktion noch die Update<\/b>-Methode des Recordsets auf. Tritt bei all diesen Befehlen kein Problem auf, gibt die Funktion den Wert True <\/b>zurück.<\/p>\n Backend auf den Server übertragen<\/b><\/p>\n Beim Übertragen des Backends auf den Server beim Schließen des Frontends müssen wir theoretisch auch den Wert der beiden Felder ZuletztVomServerKopiert <\/b>und ZuletztZumServerVerschoben <\/b>beachten, denn es kann ja sein, dass die Backend-Datenbank beim Öffnen des Frontends nicht in das Verzeichnis des Frontends kopiert wurde. In diesem Fall ist das Backend aber gar nicht im Verzeichnis des Frontends enthalten. Wir brauchen also beim Schließen des Frontends nur zu prüfen, ob das Backend im gleichen Verzeichnis enthalten ist. Das erledigen wir innerhalb einer If…Then<\/b>-Bedingung in der Funktion BackendZumServer<\/b> (siehe Listing 3). Hier versuchen wir, die Datei BackendKopieren.accdb <\/b>im aktuellen Verzeichnis des Frontends zu finden. Ist das nicht der Fall, weist die Funktion den Benutzer per Meldung darauf hin und dass die Anwendung nun geschlossen wird. Anderenfalls wird die Variable bolBackendZumServer <\/b>auf True <\/b>eingestellt.<\/p>\n Listing 3: Backend zurück zum Server kopieren<\/span><\/b><\/p>\n Den Wert dieser Variablen prüfen wir in der folgenden If…Then<\/b>-Bedingung. Ist dieser True<\/b>, ermitteln wir zunächst die Quelle und das Ziel für das Verschieben des Backends.<\/p>\n Dann erstellen wir mit der FileCopy<\/b>-Methode eine Kopie des aktuell im Serververzeichnis gespeicherten Backends. Dieses versehen wir mit dem aktuellen Datum und der aktuellen Uhrzeit, also etwa wie folgt:<\/p>\n Dann löschen wir die soeben kopierte Datei BackendKopieren.accdb <\/b>und kopieren das Backend vom Verzeichnis des Frontends zum angegebenen Ort auf dem Server. Auch hier liefert die Funktion den Wert True <\/b>zurück, wenn die entsprechende Anweisung ohne Fehler erreicht wird.<\/p>\n Beim Starten und Beenden<\/b><\/p>\n Nun müssen wir diese beiden Prozeduren nur noch beim Starten und beim Beenden der Frontend-Anwendung anstoßen. In der Beispieldatenbank verwenden wir ein Intro-Formular, das immer angezeigt wird. Das bietet die Gelegenheit, die Prozedur zum Kopieren des Backends in das Verzeichnis des Frontends beim Öffnen des Formulars aufzurufen.<\/p>\n Das erledigen wir dann auch, indem wir für die Ereignisprozudur Beim Laden <\/b>des Formulars den Wert [Ereignisprozedur] <\/b>einstellen und auf die Schaltfläche mit den drei Punkten neben der Eigenschaft klicken. Dies legt automatisch die Ereignisprozedur im Klassenmodul des Formulars an. Wir ergänzen den Code dieser Prozedur wie folgt:<\/p>\n Damit ist der Teil, der beim Öffnen ausgeführt werden soll, schon einmal erledigt. Alternativ könnten Sie auch das AutoExec<\/b>-Makro verwenden, das automatisch beim Öffnen einer Access-Datenbank ausgeführt wird und den Makrobefehl AusfuehrenCode<\/b> zum Ausführen von VBA-Prozeduren anbietet. Wie aber bringen wir die Anwendung dazu, zu erkennen, wann der Benutzer diese beendet Es gibt kein Makro wie AutoExec<\/b>, das beim Schließen einer Datenbankanwendung ausgelöst wird. Allerdings können wir einen Trick anwenden: Der Benutzer kann das Intro-Formular mit einem Klick auf die Schaltfläche cmdGO <\/b>schließen. Die dadurch ausgelöste Prozedur sieht so aus:<\/p>\n Wir können das Formular an dieser Stelle aber auch unsichtbar machen, indem wir seine Eigenschaft Visible <\/b>auf den Wert False <\/b>einstellen:<\/p>\n Was haben wir dadurch gewonnen Das Formular bleibt nun unsichtbar geöffnet und wird erst geschlossen, wenn der Benutzer auch die Anwendung schließt. Das bietet uns die Möglichkeit, für das Formular eine Ereignisprozedur zu hinterlegen, die beim Schließen des Formulars ausgelöst wird – zum Beispiel Beim Schließen <\/b>oder Beim Entladen<\/b>. In einer dieser Ereignisprozeduren fügen wir dann den Aufruf der Prozedur zum Verschieben der Backend-Datenbank zum Server ein. In diesem Fall wollen wir das Ereignis Beim Entladen <\/b>nutzen und fügen diesem zunächst die folgende Anweisung hinzu – diese wird später noch erweitert:<\/p>\n Probleme beim Kopieren<\/b><\/p>\n Das ist zumindest auf den ersten Blick ein guter Plan. Allerdings haben wir hier noch nicht im Blick, dass es sein kann, dass zu diesem Zeitpunkt noch andere Formulare als frmIntro <\/b>geöffnet sind, die noch Daten aus den verknüpften Tabellen des Backends anzeigen. Wenn wir dann versuchen, die Backend-Datei mit der FileCopy<\/b>-Methode zu kopieren, tritt der Fehler aus Bild 7 auf.<\/p>\n Bild 7: Fehler beim Versuch, das Backend mit noch geöffneten Tabellen zu kopieren<\/span><\/b><\/p>\n Wir müssen also vor dieser Aktion dafür sorgen, dass alle Tabellen geschlossen sind. Dazu erstellen wir die folgende Funktion, die alle Formulare außer frmIntro <\/b>schließt:<\/p>\n Tritt dabei kein Fehler auf, gibt die Funktion den Wert True <\/b>zurück. In der Prozedur BackendZumServer <\/b>bauen wir diese Funktion wie folgt ein:<\/p>\n Wenn beim Schließen der Formulare ein Fehler auftritt, soll also eine entsprechende Fehlermeldung erscheinen. Ganz wichtig: In die Ereignisprozedur, die durch das Ereignis Beim Entladen <\/b>ausgelöst wird, fügen wir noch die Abfrage ein, welchen Wert die Funktion Backend-ZumServer <\/b>zurückgegeben hat. Ist dieser False<\/b>, erhält der Benutzer eine Meldung, dass er selbst die geöffneten Elemente schließen und erneut die Anwendung schließen soll. Außerdem stellen wir den Parameter Cancel <\/b>auf True <\/b>ein, damit das Schließen des Formulars abgebrochen wird – was zur Folge hat, dass auch die Anwendung nicht geschlossen werden kann:<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Dieser Beitrag zeigt, wie Sie das Backend für eine Anwendung jeweils beim Öffnen der Anwendung neu vom Server kopieren, um dann damit zu arbeiten. Nach der Bearbeitung und mit dem Schließen der Anwendung soll die aktuelle Version des Backends dann wieder auf den Server zurückkopiert werden, wobei die dortige aktuelle Version zuvor in ein Backup kopiert wird. Die hier verwendeten Routinen weisen noch keine ausgefeilte Fehlerbehandlung auf. Hier könnte man noch mögliche Fehler behandeln wie etwa ein nicht mehr vorhandenes Zielverzeichnis auf dem Server. In einer Fortsetzung dieses Beitrags zeigen wir in der nächsten Ausgabe, wie Sie die Lösung so absichern, dass keine unbehandelten Fehler mehr auftreten.<\/p>\n Enthaltene Beispieldateien:<\/p>\n BackendKopieren.accdb<\/p>\n BackendKopieren_BE.accdb<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2019_06\/pic_1216_002.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2019_06\/pic_1216_003.png\")
<\/p>\nPublic Sub <\/span>VerknuepfungenAktualisieren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n If <\/span>Not<\/span> Len<\/span>(tdf.Connect) = 0 Then<\/span>\r\n tdf.Connect = \";DATABASE=\" & CurrentProject.Path & \"BackendKopieren_BE.accdb\"\r\n tdf.RefreshLink\r\n End If<\/span>\r\n Next<\/span> tdf\r\nEnd Sub<\/span><\/pre>\n;DATABASE=C:...BackendKopierenBackendKopieren_BE.accdb<\/pre>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2019_06\/pic_1216_004.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2019_06\/pic_1216_005.png\")
<\/p>\n![\"Formular](\"..\/fileadmin\/_temp_\/2019_06\/pic_1216_006.png\")
<\/p>\nPrivate Sub <\/span>cmdAuswaehlen_Click()\r\n Dim <\/span>strPfad As String<\/span>\r\n strPfad = Nz(Me!txtBackendPfad, \"\")\r\n strPfad = Mid<\/span>(strPfad, 1, InStrRev<\/span>(strPfad, \"\"))\r\n Me!txtBackendPfad = OpenFileName(strPfad, _\r\n \"Backend auf dem Server auswählen\", _\r\n \"Access-DB (*.accdb;*.accde)\")\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdOK_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\n\n
Public Function <\/span>BackendHolen() As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strQuelle As String<\/span>\r\n Dim <\/span>strZiel As String<\/span>\r\n Dim <\/span>bolBackendHolen As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblOptionen\", dbOpenDynaset)\r\n If <\/span>Nz(rst!ZuletztVomServerKopiert, 0) > Nz(rst!ZuletztZumServerVerschoben, 0) Then<\/span>\r\n If MsgBox<\/span>(\"Das Frontend wurde möglicherweise zuletzt nicht korrekt geschlossen.\" & vbCrLf<\/span> _\r\n & \"Wollen Sie das Backend dennoch neu vom Server einlesen\", vbYesNo + vbCr<\/span>itical) = vbYes Then\r\n bolBackendHolen = True<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n bolBackendHolen = True<\/span>\r\n End If<\/span>\r\n If <\/span>bolBackendHolen = True<\/span> Then<\/span>\r\n strQuelle = rst!BackendPfad\r\n strZiel = CurrentProject.Path & \"BackendKopieren_BE.accdb\"\r\n On Error Resume Next<\/span>\r\n Kill strZiel\r\n On Error GoTo<\/span> 0\r\n FileCopy strQuelle, strZiel\r\n VerknuepfungenAktualisieren\r\n rst.Edit\r\n rst!ZuletztVomServerKopiert = Now\r\n rst.Update\r\n End If<\/span>\r\n BackendHolen = True<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>BackendZumServer() As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strQuelle As String<\/span>\r\n Dim <\/span>strZiel As String<\/span>\r\n Dim <\/span>bolBackendZumServer As Boolean<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblOptionen\", dbOpenDynaset)\r\n If <\/span>Len<\/span>(Dir(CurrentProject.Path & \"BackendKopieren_BE.accdb\")) = 0 Then<\/span>\r\n MsgBox<\/span> \"Das Backend konnte nicht gefunden werden.\" & vbCrLf<\/span> _\r\n & \"Die Anwendung wird ohne Kopieren des Backends auf den Server geschlossen.\"\r\n Else<\/span>\r\n bolBackendZumServer = True<\/span>\r\n End If<\/span>\r\n If <\/span>bolBackendZumServer = True<\/span> Then<\/span>\r\n strQuelle = CurrentProject.Path & \"BackendKopieren_BE.accdb\"\r\n strZiel = rst!BackendPfad\r\n FileCopy strZiel, Replace<\/span>(strZiel, \".accdb\", \"_\" & Format(Now, \"yyyy_mm_dd_hh_nn_ss\") & \".accdb\")\r\n On Error Resume Next<\/span>\r\n Kill strZiel\r\n On Error GoTo<\/span> 0\r\n FileCopy strQuelle, strZiel\r\n rst.Edit\r\n rst!ZuletztZumServerVerschoben = Now\r\n rst.Update\r\n BackendZumServer = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nBackendKopieren_BE_2019_10_31_18_30_13.accdb<\/pre>\n
Private Sub <\/span>Form_Load()\r\n BackendHolen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdGo_Click()\r\n DoCmd.OpenForm \"frmKunden\"\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdGo_Click()\r\n DoCmd.OpenForm \"frmKunden\"\r\n Me.Visible = False<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n BackendZumServer\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2019_06\/pic_1216_007.png\")
<\/p>\nPublic Function <\/span>FormulareSchliessen() As Boolean<\/span>\r\n Dim <\/span>frm As <\/span>Form\r\n On Error Resume Next<\/span>\r\n For Each frm In Forms\r\n If <\/span>Not<\/span> frm.Name = \"frmIntro\" Then<\/span>\r\n DoCmd.Close acForm, frm.Name\r\n End If<\/span>\r\n Next<\/span> frm\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n FormulareSchliessen = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nIf <\/span>FormulareSchliessen = True<\/span> Then<\/span>\r\n ...\r\nElse<\/span>\r\n MsgBox<\/span> \"Es konnten nicht alle Formulare geschlossen werden.\"\r\nEnd If<\/span><\/pre>\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n If <\/span>BackendZumServer = False<\/span> Then<\/span>\r\n MsgBox<\/span> \"Die Anwendung konnte nicht geschlossen werden.\" & vbCrLf<\/span> & vbCrLf<\/span> _\r\n & \"Bitte schließen Sie manuell alle noch geöffneten Formulare und schließen Sie die Anwendung dann erneut.\"\r\n Cancel = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDownloads zu diesem Beitrag<\/h3>\n