<\/p>\n
Der übliche Weg, um Daten aus Tabellen in Access-Formularen anzuzeigen, ist die Angabe einer Tabelle oder Abfrage als Datenquelle und das Binden der Steuerelemente an die Felder dieser Quelle. Es gibt jedoch Anwendungsfälle, in denen diese Vorgehensweise nicht das gewünschte Ergebnis liefert. Dann kann man einen alternativen Weg gehen, auch wenn man damit viel Vorteile aufgibt und eine Menge zusätzlicher Aufwand entsteht. In diesem Beitrag erläutern wir, wie man die Daten aus Tabellen oder Abfragen auch ohne direkte Bindung an eine Tabelle oder Abfrage in einem Formular anzeigen, bearbeiten und wieder speichern kann und wie sogar das Anlegen neuer Datensätze möglich ist.<\/b><\/p>\nAnwendungsfälle für ungebundene Formulare<\/h2>\n
Access bietet mit der Bindung von Formularen und Steuerelementen an Tabellen oder Abfragen samt Feldern eine sehr einfache Möglichkeit, Daten anzuzeigen, zu bearbeiten und diese wieder zu speichern.<\/p>\n
Man kann allerdings auch den gewünschten Datensatz per VBA öffnen und die Daten auslesen und in die Steuerelemente eines Formulars schreiben. Wenn der Benutzer die gewünschten Änderungen durchgeführt hat, lassen sich diese Daten per VBA sogar wieder zurück in die Tabelle schreiben. Damit ist allerdings ein stark erhöhter Programmieraufwand verbunden. Außerdem kann man damit nur jeweils einen Datensatz in einem Formular anzeigen. Die Datenblattansicht oder die Endlosansicht können wir so nicht mit Daten füllen. Die einzige Möglichkeit, mehrere Datensätze anzuzeigen, wäre ein Listenfeld, dem wir die Daten als Wertliste zuweisen.<\/p>\n
Also fragt man sich: Aus welchem Grund sollte man sich diese Arbeit machen, wenn Access doch alle notwendigen Funktionen durch die Datenbindung anbietet? Uns fallen die folgenden Szenarien ein:<\/p>\n
In den folgenden Abschnitten erläutern wir diese Gründe etwas ausführlicher.<\/p>\n
Ein Grund für den Einsatz von ungebundenen Formularen ist die Datensicherheit. Angenommen, wir arbeiten mit einem Frontend und einem Backend, wobei die Daten im Backend durch ein Kennwort geschützt sind. Dann gibt es keine wirklich sichere Möglichkeit, per Datenbindung auf die Daten im Backend zuzugreifen, ohne dass das Kennwort abgegriffen werden kann. Dieses wird nämlich in der Verbindungszeichenfolge gespeichert – und das unverschlüsselt.<\/p>\n
In der Regel profitiert man davon, gebundene Formulare zu nutzen, denn damit werden gleich bei der Dateneingabe verschiedene Regeln wie Gültigkeitsregeln, Restriktionen durch Verknüpfungen oder Datentypen berücksichtigt. Manchmal ist das aber vielleicht nicht gewünscht.<\/p>\n
Bei ungebundenen Formularen werden die im Datenmodell definierten Regeln gar nicht berücksichtigt – dies geschieht erst beim Speichern eines geänderten oder neuen Datensatzes.<\/p>\n
Wollen zwei Benutzer auf den gleichen Datensatz zugreifen, kann das je nach festgelegtem Mechanismus für Datensatzsperrungen entweder gar nicht funktionieren oder zu Konflikten führen. Wenn man dies verhindern möchte und es okay ist, wenn die Änderungen des zuletzt auf den Datensatz zugreifenden Benutzers übernommen werden sollen, egal, ob zwischenzeitlich andere Änderungen vorgenommen wurden, kann der Einsatz eines ungebundenen Formulars sinnvoll sein. Dieses sperrt den Datensatz je nach Einstellungen maximal beim Zurückschreiben eines geänderten Datensatzes.<\/p>\n
Auch wenn es auf den ersten Blick merkwürdig aussieht: Der schnellste Weg zu einem Formular, das die Daten eines Datensatzes anzeigt, ohne an diesen gebunden zu sein, führt über das Erstellen eines herkömmlichen gebundenen Formulars.<\/p>\n
Der Grund ist einfach: Nicht nur erleichtert die Datenbindung unter Access das Anzeigen, Bearbeiten und Speichern von Daten, sondern Access ist auch optimal darauf vorbereitet, gebundene Formulare zu erstellen. Aber das wissen Sie ja bereits.<\/p>\n
Dennoch können Sie eine der beiden folgenden Alternativen nutzen:<\/p>\n
Wir denken, dass die erste Methode schneller funktioniert und wir damit außerdem die Steuerelemente sinnvoll anordnen können.<\/p>\n
Als Beispieltabelle verwenden wir eine sehr einfach gehaltene Kundentabelle namens tblKunden<\/b>, die lediglich das Primärschlüsselfeld KundeID <\/b>sowie die Textfelder Vorname<\/b>, Nachname<\/b>, Anrede<\/b>, Strasse<\/b>, PLZ<\/b>, Ort <\/b>und Land <\/b>enthält. Diese sieht mit einigen Beispieldatensätzen wie in Bild 1 aus.<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_04\/pic_1442_001.png\")
<\/p>\n
Bild 1: Tabelle mit Beispieldaten<\/span><\/b><\/p>\n Damit erstellen wir nun ein neues gebundenes Formular. Dazu gehen wir wie folgt vor:<\/p>\n Das Formular sieht nun wie in Bild 2 aus.<\/p>\n Bild 2: Das gebundene Formular<\/span><\/b><\/p>\n Nun erledigen wir die folgenden Schritte, um die Bindung von Formular und Steuerelementen aufzuheben:<\/p>\n Letzteres geht am schnellsten, indem Sie alle gebundenen Steuerelemente markieren und dann die Eigenschaft Steuerelementinhalt bearbeiten. Diese wird nun zunächst leer angezeigt, weil sie für die verschiedenen markierten Steuerelemente unterschiedliche Werte enthält (siehe Bild 3). Wie aber sollen wir eine leere Eigenschaft leeren? Dazu geben wir ein beliebiges Zeichen ein und entfernen diese wieder. Anschließend ist die Eigenschaft wirklich leer, wie das Anklicken der einzelnen Steuerelemente zeigt.<\/p>\n Bild 3: Die Eigenschaft Steuerelementinhalt wird leer angezeigt, weil die markierten Steuerelemente unterschiedliche Werte für diese Eigenschaft aufweisen.<\/span><\/b><\/p>\n Wechseln wir nun zur Formularansicht, sehen wir ein Formular mit leeren Steuerelementen, die wir nach Bedarf füllen können.<\/p>\n In einem ungebundenen Formular benötigen wir die Elemente für die Navigation in den Datensätzen nicht.<\/p>\n Daher stellen wir die Eigenschaften Navigationsschaltflächen <\/b>und Datensatzmarkierer <\/b>auf den Wert Nein <\/b>ein.<\/p>\n Nun wollen wir die Steuerelemente mit den Daten eines Datensatzes füllen. Nur welchen verwenden wir? Wir verwenden zunächst den ersten Datensatz. Später schauen wir uns an, wie wir das Formular für die Anzeige eines speziellen Datensatzes öffnen können.<\/p>\n Um das Formular mit den Daten eines Datensatzes zu versehen, benötigen wir eines der Ereignisse, die direkt beim Öffnen des Formulars ausgelöst werden. In diesem Fall nutzen wir direkt das Ereignis Beim Öffnen<\/b>. <\/p>\n Nachdem wir dieses angelegt haben, ergänzen wir die leere Prozedur um die folgenden Zeilen:<\/p>\n [<\/p>\n Diese Prozedur erstellt ein Database<\/b>– und ein Recordset<\/b>-Objekt und liest lediglich den ersten Datensatz der Tabelle tblKunden <\/b>in das Recordset ein (TOP 1<\/b>).<\/p>\n Dann schreibt sie die Werte der einzelnen Felder der Tabelle in die jeweiligen Textfelder.<\/p>\n Anschließend schließt sie das Recordset und leert die Variablen rst <\/b>und db<\/b>.<\/p>\n Öffnen wir das Formular nun in der Formularansicht, zeigt es wie in Bild 4 den gewünschten Datensatz an. Wir können die Daten nun ändern, allerdings werden die Änderungen nicht in die zugrunde liegende Tabelle übernommen.<\/p>\n Bild 4: Daten im ungebundenen Formular<\/span><\/b><\/p>\n Bevor wir dies programmieren, wollen wir nun zunächst dafür sorgen, dass wir das Formular mit einem bestimmten Datensatz öffnen können.<\/p>\n Wenn Sie ein gebundenes Formular öffnen und mit diesem direkt einen bestimmten Datensatz anzeigen wollen, haben Sie verschiedene Möglichkeiten. Eine davon ist, eine Bedingung mit dem Parameter WhereCondition <\/b>zu übergeben. So gern wir diese weiter nutzen würden: der übergebene Wert lässt sich für ungebundene Formular nicht auslesen.<\/p>\n Also gehen wir direkt zur nächsten Möglichkeit, einen Wert zu übergeben. Dazu nutzen wir den OpenArgs<\/b>-Parameter der DoCmd.OpenForm<\/b>-Methode. Damit übergeben wir den Wert des Primärschlüsselfeldes des Datensatzes, den wir im ungebundenen Formular anzeigen wollen, hier den Wert 2<\/b>:<\/p>\n Den Parameter werten wir in einer Erweiterung der Form_Open<\/b>-Methode wie folgt aus:<\/p>\n Wir weisen der Variablen lngKundeID <\/b>den Wert der Eigenschaft OpenArgs <\/b>zu. Diese enthält den übergebenen Wert oder, wenn kein Wert übergeben wurde, den Wert Null<\/b>. lngKundeID <\/b>hat dann also entweder den Primärschlüsselwert des anzuzeigenden Datensatzes oder den Wert 0<\/b>.<\/p>\n Im ersteren Fall zeigen wir mit dem Formular einfach den ersten Datensatz des Recordsets an, im letzteren den Datensatz mit dem entsprechenden Primärschlüsselwert.<\/p>\n Einfach den ersten Datensatz anzuzeigen, wenn keine ID für den anzuzeigenden Datensatz übergeben wurde, macht keinen Sinn. Also entscheiden wir, dass das Formular in diesem Fall leer angezeigt werden soll, also wie ein Formular mit einem neuen, leeren Datensatz.<\/p>\n Oder kurz gesagt: In diesem Fall lassen wir einfach alle Steuerelemente leer. Dazu bauen wir die Prozedur erneut um, indem wir die Option lngKundeID = 0 <\/b>entfernen und nur bei Vorhandensein eines Primärschlüsselwertes überhaupt Werte in die Steuerelemente eintragen:<\/p>\n Wenn Sie sich entscheiden, wie im vorliegenden Beispiel den Primärschlüsselwert des Datensatzes im Formular anzuzeigen, sollten Sie das betroffene Steuerelement deaktivieren, damit der Benutzer den Wert nicht ändern kann.<\/p>\n Das ist schließlich bei gebundenen Formularen auch nicht möglich, wenn das Feld mit der Autowertfunktion ausgestattet ist. Um das zu erreichen, stellen wir die Eigenschaften Aktiviert <\/b>auf Nein <\/b>und Gesperrt <\/b>auf Ja <\/b>ein. Damit wird das Steuerelement wie die übrigen Textfelder angezeigt, kann aber nicht bearbeitet werden. <\/p>\n Um dem Benutzer zu verdeutlichen, dass der Inhalt dieses Steuerelements nicht verändert werden kann, stellen wir seine Eigenschaft Rahmenart <\/b>noch auf Transparent <\/b>ein.<\/p>\n Mit den bisherigen Vorgaben haben wir die Messlatte für die Prozedur zum Speichern des Datensatzes direkt recht hoch angelegt. Diese muss nun nämlich unterscheiden, ob es sich bei dem angezeigten Datensatz um einen neuen oder einen vorhandenen Datensatz handelt. Und im letzteren Fall wäre es auch noch interessant, ob dieser überhaupt geändert wurde und dementsprechend gespeichert werden soll.<\/p>\n Ob es sich um einen neuen oder einen vorhandenen Datensatz handelt, können wir dem Steuerelement KundeID <\/b>entnehmen. Wenn wir dieses jedoch nicht anzeigen, benötigen wir einen anderen Marker. In diesem Fall würden wir die Deklaration der Variablen lngKundeID <\/b>aus der Prozedur Form_Open <\/b>herausziehen und diese in den allgemeinen Teil des Klassenmoduls verschieben (siehe Bild 5).<\/p>\n Bild 5: Auslagern der Variablen lngKundeID<\/span><\/b><\/p>\n Damit können wir nach dem Zuweisen des Wertes in Form_Open <\/b>auch in weiteren Ereignisprozeduren noch darauf zugreifen.<\/p>\n Damit kommen wir zu der Frage: Wann wollen wir den neuen oder geänderten Datensatz überhaupt speichern? Wenn der Benutzer das Formular schließt? Oder wenn er auf eine bestimmte Schaltfläche wie beispielsweise OK <\/b>klickt? Letzteres wäre umso sinnvoller, als dass wir dann noch eine weitere Schaltfläche mit dem Text Abbrechen <\/b>hinzufügen könnten, die dem Benutzer die Möglichkeit bietet, Änderungen an einem vorhanden oder neuen Datensatz zu verwerfen.<\/p>\n Also fügen wir die beiden Schaltflächen namens cmdOK <\/b>und cmdAbbrechen <\/b>wie in Bild 6 hinzu.<\/p>\n Bild 6: Schaltflächen zum Speichern oder Verwerfen von Änderungen<\/span><\/b><\/p>\n Wir kümmern uns zuerst um das Verwerfen von Änderungen an den Daten im Formular. Im Gegensatz zu einem gebundenen Formular, in dem wir Änderungen mit der Undo<\/b>-Methode verwerfen, brauchen wir hier nur das Formular zu schließen. Schließlich sind die Steuerelemente nicht gebunden, sodass auch keine Änderungen auf die zugrunde liegende Tabelle übertragen werden. Der Code dieser Prozedur lautet daher:<\/p>\n Das Speichern von Änderungen ist nur notwendig, wenn der Benutzer überhaupt Änderungen vorgenommen hat. Daher sollten wir zuerst prüfen, ob dies der Fall ist. Wir können uns hier leider nicht auf die Eigenschaften Value <\/b>und OldValue <\/b>eines Steuerelements berufen, die bei gebundenen Formularen zur Verfügung stehen. Stattdessen müssen wir die Werte beim Öffnen des Formulars in irgendeiner Form speichern. Es gibt verschiedene Varianten. Wir könnten beispielsweise eine String<\/b>-Variable nutzen, der wir die Inhalte aller Felder durch das Pipe-Zeichen getrennt hinzufügen, also etwa so:<\/p>\n Beim Anklicken der OK<\/b>-Schaltfläche würden wir dann die aktuellen Inhalte in einer weiteren Variablen zusammenfassen und die beiden vergleichen. Gibt es einen Unterschied, liegen Änderungen vor.<\/p>\n Etwas eleganter ist die folgende Idee: Wir speichern den Wert eines jeden Steuerelements beim Öffnen an einer beliebigen Stelle und lösen beim Ändern des Wertes, beispielsweise durch das Ereignis Nach Aktualisierung<\/b>, eine Ereignisprozedur aus, welche den gespeicherten und den aktuellen Wert vergleicht. Liegen Unterschiede vor, aktivieren wir die zuvor nicht aktivierte Schaltfläche cmdOK<\/b>. Macht der Benutzer die Änderungen rückgängig, deaktivieren wir cmdOK <\/b>wieder.<\/p>\n Um nicht für jedes Steuerelement eine Variable definieren zu müssen, speichern wir die Werte in der Tag<\/b>-Eigenschaft der Steuerelemente (im Eigenschaftenblatt unter Marke <\/b>zu finden). Dazu fügen wir der Form_Open<\/b>-Ereignisprozedur die folgenden Zeilen hinzu:<\/p>\n Für die Ereignisprozedur Nach Aktualisierung <\/b>des Textfeldes mit der Anrede <\/b>würden wir die folgende Prozedur hinterlegen:<\/p>\n Wenn wir die Eigenschaft Aktiviert <\/b>der Schaltfläche cmdOK <\/b>nun auf Nein <\/b>einstellen und nach dem Öffnen des Formulars für einen vorhandenen Datensatz die Anrede ändern, würde dies nach dem Bestätigen des neuen Wertes die Schaltfläche cmdOK <\/b>aktivieren.<\/p>\n Eine solche Prozedur können wir für alle übrigen Steuerelemente ebenfalls anlegen.<\/p>\n Was aber, wenn der Benutzer den Werte eines der Steuerelemente wieder auf den vorherigen Wert ändert? Dann können wir die Schaltfläche cmdOK <\/b>nicht einfach wieder deaktivieren, denn es kann sein, dass er bereits den Wert eines anderen Steuerelements geändert hat.<\/p>\n Für diesen Fall müssen wir also eine Prüfung aller Steuerelemente vornehmen. Dann können wir allerdings auch gleich eine Prüfung aller Steuerelemente vornehmen, was für das Feld Anrede <\/b>wie folgt aussieht:<\/p>\n Die gleiche If…Then<\/b>-Bedingung müssen wir dann für die AfterUpdate<\/b>-Prozedur aller Steuerelemente hinterlegen. Aber da wir keinen Code doppelt schreiben wollen, legen wir eine neue Prozedur dafür an.<\/p>\n Und in dieser ersetzen wir die If…Then<\/b>-Bedingung durch eine direkte Zuweisung der Bedingung an die Eigenschaft Enabled <\/b>der OK<\/b>-Schaltfläche:<\/p>\n Wichtig ist die Klammer um die mit And <\/b>verknüpften Bedingungen.<\/p>\n Der Aufruf sieht beispielsweise für das Textfeld Anrede <\/b>wie folgt aus:<\/p>\n Nun schauen wir uns die Prozedur an, die durch das Anklicken der Schaltfläche cmdOK <\/b>ausgelöst wird. Diese erzeugt als Erstes ein Recordset auf Basis der Tabelle tblKunden<\/b>, wobei dieses genau den Datensatz mit dem Wert aus lngKundeID <\/b>im Primärschlüsselfeld erhält. Bei einem vorhandenen Datensatz wird dieser geladen, bei einem neuen ist lngKundeID <\/b>gleich 0 <\/b>und dementsprechend wird ein leeres Recordset ermittelt:<\/p>\n Erst dann prüft die Prozedur, ob es sich um einen neuen Datensatz handelt (lngKundeID = 0<\/b>) oder um einen vorhandenen. Im ersten Fall legt es mit der AddNew<\/b>-Methode einen neuen Datensatz im noch leeren Recordset an, im zweiten wird der enthaltene Datensatz in den Bearbeitungszustand versetzt:<\/p>\n Danach schreibt die Prozedur die aktuellen Werte der Textfelder in die Felder des Recordsets und speichert dieses anschließend:<\/p>\n Schließlich wird das Formular geschlossen:<\/p>\n Auf diese Weise können wir mit dem Formular vorhandene Datensätze bearbeiten und neue anlegen.<\/p>\n Die aktuelle Fassung eines ungebundenen Formulars ermöglicht das Bearbeiten vorhandener Datensätze sowie das Erstellen neuer Datensätze. Allein hierfür mussten wir bereits eine Reihe Prozeduren und Anweisungen schreiben.<\/p>\n Dabei fehlen noch einige Funktionen gebundener Formular, die wir hier noch nicht berücksichtigt haben. Darunter gehören die folgenden:<\/p>\n Es erfolgt keine Prüfung, ob die eingegebenen Daten gültig sind. Dies würde in einen gebundenen Formular bereits beim Verlassen des jeweiligen Steuerelements geschehen. Auch untersucht diese Version nicht, ob Werte vorhanden sein müssen oder ob der Datentyp dem Typ des jeweiligen Feldes entspricht.<\/p>\n Wir können beliebige Daten in die Steuerelemente eingeben, aber erst beim Speichern durch die Update<\/b>-Methode des Recordsets in der Prozedur cmdOK_Click <\/b>werden eventuelle Probleme gemeldet.<\/p>\n Dadurch, das wir hier nur Textfelder verwenden, die alle auch leer bleiben dürfen, tritt an dieser Stelle kein Problem auf. Wie es aussehen könnte, wenn dies der Fall ist, zeigen wir an einem Beispiel. Wir stellen in der Tabelle tblKunden <\/b>für das Feld Anrede <\/b>die Eigenschaft Eingabe erforderlich <\/b>auf Ja <\/b>ein. Versuchen wir nun, einen neuen Datensatz anzulegen, bei dem dieses Feld nicht gefüllt wird, erhalten wir die Meldung aus Bild 7.<\/p>\nSchritt 1: Gebundenes Formular erstellen<\/h2>\n
\n
![\"Das](\"..\/fileadmin\/_temp_\/2023_04\/pic_1442_002.png\")
<\/p>\nSchritt 2: Formularbindung aufheben<\/h2>\n
\n
![\"Die](\"..\/fileadmin\/_temp_\/2023_04\/pic_1442_003.png\")
<\/p>\nUnnötige Elemente entfernen<\/h2>\n
Ersten Datensatz der Tabelle oder Abfrage anzeigen<\/h2>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT TOP 1 * \" _\r\n & \"FROM tblKunden\", dbOpenDynaset)\r\n Me!KundeID = rst!KundeID\r\n Me!Vorname = rst!Vorname\r\n Me!Nachname = rst!Nachname\r\n Me!Anrede = rst!Anrede\r\n Me!Strasse = rst!Strasse\r\n Me!PLZ = rst!PLZ\r\n Me!Ort = rst!Ort\r\n Me!Land = rst!Land\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Daten](\"..\/fileadmin\/_temp_\/2023_04\/pic_1442_004.png\")
<\/p>\nFormular mit gewünschtem Datensatz öffnen<\/h2>\n
DoCmd.OpenForm \"frmKundenUngebunden\", OpenArgs:=\"2\"<\/pre>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n lngKundeID = Nz(Me.OpenArgs, 0)\r\n If <\/span>lngKundeID = 0 Then<\/span>\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT TOP 1 * \" _\r\n & \"FROM tblKunden\", dbOpenDynaset)\r\n Else<\/span>\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT TOP 1 * \" _\r\n & \"FROM tblKunden WHERE KundeID = \" _\r\n & lngKundeID, dbOpenDynaset)\r\n End If<\/span>\r\n ...\r\nEnd Sub<\/span><\/pre>\nNeuen, leeren Datensatz anzeigen<\/h2>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n lngKundeID = Nz(Me.OpenArgs, 0)\r\n If <\/span>Not<\/span> lngKundeID = 0 Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT TOP 1 * \" _\r\n & \"FROM tblKunden WHERE KundeID = \" _\r\n & lngKundeID, dbOpenDynaset)\r\n Me!KundeID = rst!KundeID\r\n ...\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDeaktivieren des Steuerelements mit dem Primärschlüsselwert<\/h2>\n
Speichern des Datensatzes<\/h2>\n
![\"Auslagern](\"..\/fileadmin\/_temp_\/2023_04\/pic_1442_005.png\")
<\/p>\n![\"Schaltflächen](\"..\/fileadmin\/_temp_\/2023_04\/pic_1442_006.png\")
<\/p>\nVerwerfen von Änderungen<\/h2>\n
Private Sub <\/span>cmdAbbrechen_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nSpeichern von Änderungen<\/h2>\n
André|Minhorst|Herr|Borkhofer Str. 17|47137|Duisburg|Deutschland<\/pre>\n
...\r\nMe!Vorname.Tag = rst!Vorname\r\nMe!Nachname.Tag = rst!Nachname\r\nMe!Anrede.Tag = rst!Anrede\r\nMe!Strasse.Tag = rst!Strasse\r\nMe!PLZ.Tag = rst!PLZ\r\nMe!Ort.Tag = rst!Ort\r\nMe!Land.Tag = rst!Land\r\n...<\/pre>\n
Private Sub <\/span>Anrede_AfterUpdate()\r\n If <\/span>Not<\/span> Me!Anrede.Tag = Me!Anrede Then<\/span>\r\n Me!cmdOK.Enabled = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Anrede_AfterUpdate()\r\n If Me!Anrede.Tag = Me!Anrede _\r\n And Me!Vorname.Tag = Me!Vorname _\r\n And Me!Nachname.Tag = Me!Nachname _\r\n And Me!Strasse.Tag = Me!Strasse _\r\n And Me!PLZ.Tag = Me!PLZ _\r\n And Me!Ort.Tag = Me!Ort _\r\n And Me!Land.Tag = Me!Land Then\r\n Me!cmdOK.Enabled = False<\/span>\r\n Else<\/span>\r\n Me!cmdOK.Enabled = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>EnableOKButton()\r\n Me!cmdOK.Enabled = Not<\/span> (Me!Anrede.Tag = Me!Anrede _\r\n And Me!Vorname.Tag = Me!Vorname _\r\n And Me!Nachname.Tag = Me!Nachname _\r\n And Me!Strasse.Tag = Me!Strasse _\r\n And Me!PLZ.Tag = Me!PLZ _\r\n And Me!Ort.Tag = Me!Ort _\r\n And Me!Land.Tag = Me!Land)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Anrede_AfterUpdate()\r\n EnableOKButton\r\nEnd Sub<\/span><\/pre>\nSpeichern eines neuen oder geänderten Datensatzes<\/h2>\n
Private Sub <\/span>cmdOK_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKunden \" _\r\n & \"WHERE KundeID = \" & lngKundeID, dbOpenDynaset)<\/pre>\n If <\/span>lngKundeID = 0 Then<\/span>\r\n rst.AddNew<\/span>\r\n Else<\/span>\r\n rst.Edit\r\n End If<\/span><\/pre>\n rst!Vorname = Me!Vorname\r\n rst!Nachname = Me!Nachname\r\n rst!Anrede = Me!Anrede\r\n rst!Strasse = Me!Strasse\r\n rst!PLZ = Me!PLZ\r\n rst!Ort = Me!Ort\r\n rst!Land = Me!Land\r\n rst.Update\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing<\/pre>\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2023_04\/pic_1442_007.png\")
<\/p>\n