{"id":55000176,"date":"2019-04-01T00:00:00","date_gmt":"2020-03-27T19:37:29","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=176"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Aenderungen_erkennen_und_verwerfen","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Aenderungen_erkennen_und_verwerfen\/","title":{"rendered":"Änderungen erkennen und verwerfen"},"content":{"rendered":"

\n

Unter Access können Sie beispielsweise mit der Escape-Taste die aktuellen ungespeicherten Änderungen an einem Datensatz verwerfen. Das Formular zeigt dann direkt die Daten an, die beim letzten Speichern in den gebundenen Feldern enthalten waren. Dieses Verhalten wollen wir auch für Fenster abbilden, die an ein Element gebunden sind und die Daten in einer Detailansicht anzeigen. Wir wollen erkennen, ob der Benutzer Änderungen an einem Datensatz vorgenommen hat und in Abhängigkeit davon eine Rückgängig-Schaltfläche aktivieren oder deaktivieren. Durch einen Klick auf die Schaltfläche sollen die vorherigen Werte wiederhergestellt werden. Wie das gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n

Ein WPF-Fenster bietet nicht automatisch eine Dirty<\/b>-Eigenschaft wie ein gebundenes Access-Formular. Eine solche Funktion müssen wir selbst zu einem Fenster hinzufügen. Das Ergebnis dieses Artikels soll etwa wie in Bild 1 aussehen. Das Ändern eines Eintrags und das Verlassen dieses Eintrags sollen dafür sorgen, dass die Rückgängig<\/b>-Schaltfläche aktiviert wird.<\/p>\n

\"Aktivieren<\/p>\n

Bild 1: Aktivieren der Abbrechen-Schaltfläche nach einer Änderung<\/span><\/b><\/p>\n

Betätigt der Benutzer dann die Rückgängig<\/b>-Schaltfläche, soll der Datensatz auf die Version beim Laden zurückgesetzt werden (siehe Bild 2).<\/p>\n

\"Zurücksetzen<\/p>\n

Bild 2: Zurücksetzen des Datensatzes nach Betätigen der Abbrechen-Schaltfläche<\/span><\/b><\/p>\n

Vorbereitung<\/h2>\n

Wir nutzen wieder eine Anwendung auf Basis der Vorlage Visual Basic|Windows Desktop|WPF-App (.NET Framework)<\/b>. Dieser fügen wir ein neues Element des Typs ADO.NET Entity Data Model <\/b>hinzu und legen für dieses den Namen BestellverwaltungContext <\/b>fest. Dann fügen wir mit den Methoden der Datenbankdatei AccessZuWPFFormulare.accdb <\/b>(siehe dortigen Readme-Bericht) ein Fenster auf Basis des Formulars frmKundendetails <\/b>hinzu. Der Entwurf dieses Fensters sieht anschließend wie in Bild 3 aus.<\/p>\n

\"Entwurf<\/p>\n

Bild 3: Entwurf des Fensters frmKundendetails<\/span><\/b><\/p>\n

Nun wollen wir erreichen, dass die Rückgängig<\/b>-Schaltfläche beim Anzeigen des Fensters deaktiviert ist und erst aktiviert wird, wenn der Benutzer bei mindestens einem Feld eine Änderung vorgenommen hat. Wenn der Benutzer die dann aktivierte Schaltfläche Rückgängig<\/b> betätigt, sollen die Änderungen rückgängig gemacht werden beziehungsweise die Werte zum Zeitpunkt des Öffnens des Fensters wieder eingestellt werden.<\/p>\n

Speichern beim Schließen<\/h2>\n

Wir beginnen mit den einfachen Teil: Die Schaltfläche btnOK <\/b>soll den geänderten Datensatz in die Datenbank übertragen. Das erledigen wir mit der folgenden Ergänzung der Ereignismethode btnOK_Click<\/b>:<\/p>\n

Private Sub <\/span>cmdOK_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n     dbContext.SaveChanges()\r\n     Close()\r\nEnd Sub<\/span><\/pre>\n
Ereignis beim Ändern auslösen<\/h2>\n
Dann wollen wir ein Ereignis finden, das durch das Ändern eines Eintrags und das Verlassen des Feldes ausgelöst wird. Das scheint uns ausreichend zu sein – wir müssen ja nicht nach der Eingabe eines jeden Buchstaben prüfen, ob sich etwas geändert hat. Der erste Kandidat für eine passende Ereignismethode heißt LostFocus<\/b>. Also fügen wir das Attribut zum XAML-Code hinzu.<\/p>\n
<TextBox x:Name=\"txtFirma\" Text=\"{Binding Kunde.Firma}\" Height=\"21\" Margin=\"118,31,0,0\" Width=\"221\" LostFocus=\"txtFirma_LostFocus\"\/><\/pre>\n
Wenn wir LostFocus=” <\/b>eingeben und dann die Tabulator-Taste betätigen, wird automatisch der Methodenname txtFirma_LostFocus <\/b>vorgeschlagen. Durch Betätigen von F12 <\/b>landen wir dann direkt bei dieser Methode im Code behind-Modul.<\/p>\n
Mit der folgenden Testanweisung können wir gleich nach dem Starten der Anwendung testen, ob das Verlassen des Textfeldes txtFirma <\/b>das Ereignis auslöst:<\/p>\n
Private Sub <\/span>txtFirma_LostFocus(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n     MessageBox.Show(\"LostFocus\")\r\nEnd Sub<\/span><\/pre>\n
Herausfinden, ob eine Änderung vorliegt<\/h2>\n
Dieser Ereignismethode wollen wir nun Code hinzufügen, mit dem wir prüfen können, ob eine Änderung im aktuell angezeigten Element des Typs Kunde <\/b>vorliegt.<\/p>\n
Dazu benötigen wir zunächst einen Verweis auf den Namespace System.Data.Entity.Infrastructure<\/b>, den wir im Kopf des Code behind-Moduls einfügen. System.Data.Entity <\/b>benötigen wir später auch noch:<\/p>\n
Imports System.Data.Entity.Infrastructure\r\nImports System.Data.Entity<\/pre>\n
Danach erweitern wir die Ereignismethode wie folgt: Wir fügen eine Variable des Typs DbEntityEntry <\/b>namens GeaendertesElement <\/b>hinzu. Dieses füllen wir über die Auflistung Entries <\/b>des ChangeTracker<\/b>-Objekts, das dem aktuell in Kunde gespeicherten Element entspricht. Dieser Auflistung entnehmen wir mit der First<\/b>-Eigenschaft das erste und einzige Element. Dann geben wir in einer weiteren MessageBox <\/b>den aktuellen Zustand dieses Elements aus, den wir über die Eigenschaft State <\/b>ermitteln:<\/p>\n
Private Sub <\/span>txtFirma_LostFocus(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n     Dim <\/span>GeaendertesElement As <\/span>DbEntityEntry\r\n     GeaendertesElement = dbContext.ChangeTracker.Entries().Where(Function(x) x.Entity Is Kunde).First()\r\n     MessageBox.Show(\"Element geändert \" + GeaendertesElement.State.ToString())\r\nEnd Sub<\/span><\/pre>\n
Das Ergebnis sieht wie in Bild 4 aus. Der Zustand Unchanged <\/b>entspricht nun nicht dem, was wir erwartet haben.<\/p>\n
\"Aktueller<\/p>\n
Bild 4: Aktueller Zustand des Elements<\/span><\/b><\/p>\n
Erst, wenn wir zum geänderten Datensatz zurückwechseln und dann erneut das Ereignis LostFocus <\/b>auslösen, erscheint der Wert Modified <\/b>im Meldungsfenster (siehe Bild 5).<\/p>\n
\"Aktueller<\/p>\n
Bild 5: Aktueller Zustand des Elements, diesmal geändert<\/span><\/b><\/p>\n
Offensichtlich ist der neue Wert im zugrundeliegenden Element Kunde <\/b>beim Auslösen des LostFocus<\/b>-Ereignisses noch nicht angekommen.<\/p>\n
Also ist LostFocus <\/b>wohl nicht unser Ereignis. Dementsprechend kommen wir auch mit einem Ereignis wie TextChanged <\/b>nicht weiter, denn möglicherweise benötigen wir einen abgeschlossenen Fokuswechsel, um die Änderung in das Kunde<\/b>-Element zu übertragen.<\/p>\n
Änderung nach Fokuserhalt<\/h2>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t