- \n
- Added<\/b>: Hinzugefügtes Element, das noch nicht in der Datenbank existiert<\/li>\n
- Modified<\/b>: Geändertes Element, dessen Änderungen noch nicht in die Datenbank übertragen wurden<\/li>\n
- Deleted<\/b>: Gelöschtes Element, das noch in der Datenbank existiert<\/li>\n
- Unchanged<\/b>: Nicht geändertes Element<\/li>\n
- Detached<\/b>: Nicht verbundenes, also nicht zu einem DbSet <\/b>gehörendes Element. Dieses wird auch nicht vom ChangeTracker verfolgt.<\/li>\n<\/ul>\n
Beispiele zur ChangeTracker-Klasse<\/h2>\n
Wir schauen uns die verschiedenen Zustände an einfachen Beispielen an. Dazu fügen wir der Klasse MainWindow.xaml.vb <\/b>zunächst die folgenden Namespaces hinzu:<\/p>\n
Imports System.Data.Entity\r\nImports System.Data.Entity.Infrastructure<\/pre>\n
Danach erstellen wir die folgende Ereignismethode für die erste Schaltfläche btnUnveraendert<\/b>. Hier füllen wir die Variable dbContext <\/b>mit einer neuen Instanz des Datenbankkontextes und füllen das Objekt Kunde <\/b>des Typs Kunde <\/b>mit dem ersten Eintrag der Liste Kunden <\/b>des Datenbankbankkontextes:<\/p>\n
Private Sub <\/span>btnUnveraendert_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n Dim <\/span>dbContext As <\/span>BestellverwaltungContext\r\n Dim <\/span>Element As <\/span>EntityEntry\r\n Dim <\/span>Kunde As <\/span>Kunde\r\n dbContext = New<\/span> BestellverwaltungContext\r\n Kunde = dbContext.Kunden.First()<\/pre>\nDanach folgt der erste Zugriff auf den ChangeTracker<\/b>. Dabei durchlaufen wir dessen Entries<\/b>-Auflistung und referenzieren das aktuelle Element jeweils mit der Variablen Element<\/b>, die übrigens den Typ EntityEntry <\/b>aufweist (dafür auch der Verweis auf den Namespace). Anschließend geben wir für jeden Eintrag zwei Informationen aus – den Namen des Elementtyps und den Zustand. Um den Namen des Elementtyps zu erhalten, referenzieren wir zunächst die in Element <\/b>enthaltene Entität mit der Eigenschaft Entity <\/b>und ermitteln den Namen des Typs mit GetType().Name<\/b>. Den Zustand dieses Eintrags liefert die Eigenschaft State <\/b>des EntityEntry<\/b>-Elements:<\/p>\n
For Each Element In dbContext.ChangeTracker.Entries\r\n Debug.Print<\/span>(\"Elementname: \" + Element.Entity.GetType().Name + \" Status: \" + Element.State.ToString())\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nDas Ergebnis sieht schließlich wie in Bild 1 aus. Der Typ Kunde <\/b>wird korrekt erkannt und auch der Status entspricht mit Unchanged <\/b>den Erwartungen.<\/p>\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2019_02\/pic_177_001.png\")
<\/p>\nBild 1: Ausgabe von Typ und Status einer Entität<\/span><\/b><\/p>\n
ChangeTracker verfolgt alle Elementtypen<\/h2>\n
Wir fügen eine Variable für ein Element eines weiteren Elementtypen namens Anrede <\/b>hinzu und lesen auch hier den ersten Eintrag aus – in diesem Fall aus der Liste Anreden<\/b>:<\/p>\n
Dim <\/span>Anrede As <\/span>Anrede\r\n...\r\nAnrede = dbContext.Anreden.First()<\/pre>\nDie Ausgabe im Ausgabefenster sieht nach dem erneuten Start der Anwendung dem Betätigen der Schaltfläche wie folgt aus:<\/p>\n
Elementname: Kunde Status: Unchanged\r\nElementname: Anrede Status: Unchanged<\/pre>\n
Wir sehen also, dass die Entries<\/b>-Auflistung der ChangeTracker<\/b>-Klasse Elemente aller Typen umfasst – sie müssen nur in den Speicher geladen sein.<\/p>\n
Ein Element löschen<\/h2>\n
Im nächsten Beispiel wollen wir untersuchen, was beim Löschen eines Eintrags geschieht. Dazu legen wir eine neue Schaltfläche namens btnGeloeschterEintrag <\/b>hinzu, für deren Click<\/b>-Ereignis wir die folgende Ereignismethode hinterlegen:<\/p>\n
Private Sub <\/span>btnGeloeschterEintrag_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n Dim <\/span>dbContext As <\/span>BestellverwaltungContext\r\n Dim <\/span>Bestellposition As <\/span>Bestellposition\r\n Dim <\/span>Element As <\/span>DbEntityEntry\r\n dbContext = New<\/span> BestellverwaltungContext\r\n Bestellposition = dbContext.Bestellpositionen.First()\r\n dbContext.Bestellpositionen.Remove(Bestellposition)\r\n For Each Element In dbContext.ChangeTracker.Entries\r\n MessageBox.Show(\"Elementname: \" + Element.Entity.GetType().Name + vbCrLf<\/span> + \" Status: \" _\r\n + Element.State.ToString())\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nHier laden wir nun das erste Element der Auflistung Bestellpositionen<\/b>, da wir diese ohne Probleme löschen können – die Einträge haben keine Beziehungen, deren Restriktion ein Löschen verhindern könnte. Dann löschen wir dieses Element mit der Remove<\/b>-Methode aus der Auflistung Bestellpositionen<\/b>. Anschließend rufen wir wieder die gleiche For Each<\/b>-Schleife über die Entries<\/b>-Auflistung. Diesmal liefert die State<\/b>-Eigenschaft den Wert Deleted<\/b>.<\/p>\n
Ein Element hinzufügen<\/h2>\n
Nun erstellen wir ein neues Kunde<\/b>-Element, füllen seine Eigenschaften und fügen das Kunde<\/b>-Element mit der Add<\/b>-Methode zur Auflistung Kunden <\/b>hinzu:<\/p>\n
Kunde = New<\/span> Kunde\r\nWith<\/span> Kunde\r\n .Vorname = \"André\"\r\n .Nachname = \"Minhorst\"\r\n .AnredeID = 1\r\n .Strasse = \"Borkhofer Str. 17\"\r\n .PLZ = \"47137\"\r\n .Ort = \"Duisburg\"\r\n .Land = \"Deutschland\"\r\n .EMail = \"andre@minhorst.com\"\r\nEnd With<\/span>\r\ndbContext.Kunden.Add(Kunde)\r\nElement = dbContext.ChangeTracker.Entries.First\r\nMessageBox.Show(\"Elementname: \" + Element.Entity.GetType().Name + vbCrLf<\/span> + \" Status: \" + Element.State.ToString())<\/pre>\nHier lautet der Wert von State <\/b>nun Added<\/b>.<\/p>\n
Ein Element ändern<\/h2>\n
Wir legen noch eine neue Schaltfläche an, mit der wir ein bestehendes Element ändern. Dazu weisen wir dem Feld Vorname <\/b>des Kunde<\/b>-Elements einen anderen Wert zu. Da wir wissen, dass wir gerade nur einen Eintrag geändert haben, durchlaufen wir keine Schleife mehr, sondern greifen über die First<\/b>-Eigenschaft auf das geänderte Element zu:<\/p>\n
Kunde = dbContext.Kunden.First()\r\nKunde.Vorname = \"André\"\r\nElement = dbContext.ChangeTracker.Entries.First\r\nMessageBox.Show(\"Elementname: \" + Element.Entity.GetType().Name + vbCrLf<\/span> + \" Status: \" + Element.State.ToString())<\/pre>\nIn diesem Fall liefert die Eigenschaft State<\/b> den Wert Modified<\/b>.<\/p>\n
Nicht verbundene Elemente<\/h2>\n
Es kann auch sein, dass Sie ein Element neu erstellen, aber dieses nicht mit der Add<\/b>-Methode zur Auflistung des entsprechenden Elementtyps hinzufügen. Um zu untersuchen, welchen Zustand dieses Element hat und ob es vom ChangeTracker <\/b>erfasst wird, müssen wir hier hier einen anderen Weg gehen. Wir finden nämlich, wie die zweite MessageBox <\/b>zeigt, keinen Eintrag in der ChangeTracker<\/b>-Liste Entries <\/b>vor – das Ergebnis der Count<\/b>-Eigenschaft ist 0<\/b>. Um ein DbEntityEntry<\/b>-Element auf Basis des neuen Kunde<\/b>-Objekts zu erstellen, greifen wir nun nicht auf die Entries<\/b>-Liste der ChangeTracker<\/b>-Klasse zu, sondern auf die Entry<\/b>-Eigenschaft von dbContext <\/b>für das Kunde<\/b>-Objekt. Für dieses erhalten wir dann als State <\/b>den Wert Detached<\/b>, also nicht verbunden:<\/p>\n
Dim <\/span>dbContext As <\/span>BestellverwaltungContext\r\nDim <\/span>Kunde As <\/span>Kunde\r\nDim <\/span>Element As <\/span>DbEntityEntry\r\ndbContext = New<\/span> BestellverwaltungContext\r\nKunde = New<\/span> Kunde\r\nWith<\/span> Kunde\r\n .Vorname = \"André\"\r\n ...\r\nEnd With<\/span>\r\nElement = dbContext.Entry(Kunde)\r\nMessageBox.Show(\"Elementname: \" + Element.Entity.GetType().Name + vbCrLf<\/span> + \" Status: \" + Element.State.ToString())\r\nMessageBox.Show(\"Anzahl Elemente Changetracker: \" + dbContext.ChangeTracker.Entries.Count().ToString())<\/pre>\nUnterschied zwischen Entry(Element) und ChangeTracker.Entries<\/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 - Modified<\/b>: Geändertes Element, dessen Änderungen noch nicht in die Datenbank übertragen wurden<\/li>\n