{"id":55000092,"date":"2017-08-01T00:00:00","date_gmt":"2020-03-27T19:27:14","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=92"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Basics_ObservableCollection","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Basics_ObservableCollection\/","title":{"rendered":"Basics: ObservableCollection"},"content":{"rendered":"

Unter WPF gibt es einige Mechanismen, welche die Bindung der Steuerelemente an die zugrunde liegenden Daten in einem gewissen Rahmen automatisieren. Diese werden durch die Programmierung bestimmt – entweder durch die Verwendung bestimmter Schnittstellen für Eigenschaften oder auch durch entsprechende Auflistungstypen, die dann als Datenquelle etwa für Listen-Elemente verwendet werden. Mit der PropertyChanged-Schnittstelle haben wir schon die Synchronisierung zwischen den Attributen der XAML-Definition und Eigenschaften in den Code-Klassen besprochen (siehe Artikel “Basics: PropertyChanged”). In diesem Artikel schauen wir uns nun den Auflistungstyp ObservableCollection an.<\/b><\/p>\n

Beispielanwendung<\/h2>\n

Die Beispielanwendung verwendet die auch in den anderen Artikeln genutzte SQLite-Datenbank Bestellverwaltung.db<\/b>. Wir wollen daraus die Tabelle Kunden <\/b>nutzen, um die Unterschiede zwischen einer normalen Liste (List<\/b>) und einer ObservableCollection <\/b>zu demonstrieren.<\/p>\n

Die ObservableCollection<\/b>-Klasse ist eine Alternative beispielsweise zur List<\/b>-Klasse. Der wesentliche Unterschied ist, dass die ObservableCollection<\/b>-Klasse externe Objekte, die den Inhalt einer ObservableCollection <\/b>anzeigen, über Änderungen informiert.<\/p>\n

Änderungen können dabei etwa das Hinzufügen oder Entfernen von Elementen sein. Beispiele für Steuer-elemente, die Sie an Objekte auf Basis der Klasse ObservableCollection <\/b>binden können, sind etwa das ListBox<\/b>-Element oder das DataGrid<\/b>-Element.<\/p>\n

Was aber heißt überhaupt “informieren” in diesem Zusammenhang Wenn Sie etwa unter Access ein Listenfeld an eine Tabelle gebunden und dann einen Datensatz dieser Tabelle gelöscht haben, wurde der Datensatz nach dem Aufruf der Requery<\/b>-Methode des Listenfeldes auch aus dem Listenfeld entfernt. In einem Formular in der Datenblattansicht führte das Löschen eines Datensatzes direkt zum Entfernen dieses Eintrags aus der Ansicht – sehr praktisch, aber auch logisch, da hier direkt die Tabelle an das Formular gebunden war. Unter WPF ist das alles etwas anders – hier binden Sie ja beispielsweise nicht direkt an Tabellen oder Abfragen, sondern an Auflistungen wie das List<\/b>-Objekt, Collection <\/b>oder ObservableCollection<\/b>, die Sie zuvor noch mit den Daten aus der Datenbank füllen. Wenn Sie nun Änderungen an einem List<\/b>– oder Collection<\/b>-Objekt durchführen, wie es etwa geschieht, wenn Sie etwa einen neuen Eintrag hinzufügen oder einen Eintrag löschen, dann wirken sich die Änderungen zwar auf die Einträge des List<\/b>– oder Collection<\/b>-Objekts aus, aber sie schlagen sich nicht in der Benutzeroberfläche nieder.<\/p>\n

Und hier tritt das ObservableCollection<\/b>-Objekt auf den Plan: Wenn Sie diesem einen neuen Eintrag hinzufügen oder einen Eintrag entfernen, löst dies ein Ereignis aus, das automatisch von bestimmten Elementen der Benutzeroberfläche wie etwa dem ListBox<\/b>– oder dem DataGrid<\/b>-Element implementiert wird und dafür sorgt, dass die Ansicht aktualisiert wird. Um uns dies einmal an einem Beispiel anzusehen, haben wir das Fenster aus Bild 1 erstellt.<\/p>\n

\"Beispiel<\/p>\n

Bild 1: Beispiel für an ein List- und ein ObservableCollection-Objekt gebundene DataGrid-Steuerelemente<\/span><\/b><\/p>\n

Die Definition dieser Steuer-elemente finden Sie in Listing 1. Das erste DataGrid namens dgList <\/b>ist an das Objekt KundenList <\/b>der Code behind-Klasse gebunden, das zweite DataGrid namens dgObservableCollection <\/b>an das Objekt KundenObservableCollection<\/b>. Zu jedem DataGrid<\/b>-Steuerelement haben wir jeweils eine Hinzufügen- und eine Entfernen-Schaltfläche hinzugefügt, mit denen Sie per Code jeweils einen neuen Datensatz anlegen beziehungsweise den aktuell markierten Datensatz aus dem zugrunde liegenden Auflistungsobjekt entfernen. Wir werden dann später erkennen, wo die Unterschiede zwischen dem List<\/b>– und dem ObservableCollection<\/b>-Objekt liegen.<\/p>\n

<Window x:Class=\"ObservableCollection.MainWindow\" ...  Title=\"MainWindow\" Height=\"350\" Width=\"525\">\r\n     <Grid>\r\n         <Grid.ColumnDefinitions>\r\n             <ColumnDefinition><\/ColumnDefinition>\r\n             <ColumnDefinition><\/ColumnDefinition>\r\n         <\/Grid.ColumnDefinitions>\r\n         <Grid.RowDefinitions>\r\n             <RowDefinition Height=\"*\"><\/RowDefinition>\r\n             <RowDefinition Height=\"Auto\"><\/RowDefinition>\r\n         <\/Grid.RowDefinitions>\r\n         <DataGrid x:Name=\"dgList\" Grid.Column=\"0\" Margin=\"5\" ItemsSource=\"{Binding KundenList}\"><\/DataGrid>\r\n         <DataGrid x:Name=\"dgObservableCollection\" Margin=\"5\" Grid.Column=\"1\" \r\n             ItemsSource=\"{Binding KundenObservableCollection}\"><\/DataGrid>\r\n         <StackPanel Grid.Row=\"1\" Grid.Column=\"0\" Orientation=\"Horizontal\">\r\n             <Button x:Name=\"btnListAdd\" Margin=\"5\" Click=\"btnListAdd_Click\">Add<\/Button>\r\n             <Button x:Name=\"btnListDelete\" Margin=\"5\" Click=\"btnListDelete_Click\">Delete<\/Button>\r\n         <\/StackPanel>\r\n         <StackPanel Grid.Row=\"1\" Grid.Column=\"1\" Orientation=\"Horizontal\">\r\n             <Button x:Name=\"btnObservableCollectionAdd\" Margin=\"5\" Click=\"btnObservableCollectionAdd_Click\">Add<\/Button>\r\n             <Button x:Name=\"btnObservableCollectionDelete\" Margin=\"5\" \r\n                 Click=\"btnObservableCollectionDelete_Click\">Delete<\/Button>\r\n         <\/StackPanel>\r\n     <\/Grid>\r\n<\/Window><\/pre>\n
Listing 1: Definition der beiden DataGrid-Elemente und der Schaltflächen zum Hinzufügen und Löschen der Elemente<\/span><\/b><\/p>\n
DataGrid-Elemente füllen<\/h2>\n
Damit die beiden DataGrid<\/b>-Elemente gefüllt werden, haben wir der Code behind-Klasse etwas Code hinzugefügt. Im allgemeinen Teil haben wir dazu zunächst eine Objektvariable für den Datenbankkontext deklariert:<\/p>\n
BestellverwaltungEntities dbContext;<\/pre>\n
Dann benötigen wir ein List<\/b>-Objekt namens kundenList<\/b>, das Elemente des Typs Kunde <\/b>aufnehmen soll und über die öffentliche Eigenschaft KundenList <\/b>per get <\/b>und set <\/b>verfügbar gemacht wird:<\/p>\n
private List<Kunde> kundenList;\r\npublic List<Kunde> KundenList {\r\n     get {\r\n         return kundenList;\r\n     }\r\n     set {\r\n         kundenList = value;\r\n     }\r\n}<\/pre>\n
Das Gleiche haben wir für ein Auflistungs-Element des Typs ObservableCollection <\/b>durchgeführt. Dieses heißt allerdings kundenObservableCollection <\/b>und wird wie folgt definiert:<\/p>\n
private ObservableCollection<Kunde> kundenObservableCollection;\r\npublic ObservableCollection<Kunde> KundenObservableCollection {\r\n     get {\r\n         return kundenObservableCollection;\r\n     }\r\n     set {\r\n         kundenObservableCollection = value;\r\n     }\r\n}<\/pre>\n
Damit Sie das ObservableCollection<\/b>-Objekt überhaupt nutzen können, müssen Sie dieses zunächst über den passenden Namespace in der Klasse bekannt machen. Dies erledigen Sie mit der folgenden Zeile, die Sie zu den bestehenden using<\/b>-Anweisungen hinzufügen:<\/p>\n
using System.Collections.ObjectModel;<\/pre>\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