{"id":55000041,"date":"2016-06-01T00:00:00","date_gmt":"2020-03-27T19:20:29","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=41"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"WPFDatenbindung_ListenObjekte","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/WPFDatenbindung_ListenObjekte\/","title":{"rendered":"WPF-Datenbindung: Listen-Objekte"},"content":{"rendered":"

Wenn Sie WPF-Anwendungen erstellen wollen, wollen Sie die Daten der Anwendung in entsprechenden Fenstern darstellen. Ein Weg zu diesem Ziel ist das Bereitstellen der Daten in Listenform, also etwa als Collection oder Dictionary. Dieser Artikel zeigt, welche Schritte nötig sind, um eine Liste von Objekten auf Basis einer einfachen Klasse zu erstellen und seine Daten in geeigneten Listen-Steuerelementen eines WPF-Fensters anzuzeigen.<\/b><\/p>\n

Im Beitrag WPF-Datenbindung: Einfache Objekte <\/b>haben wir uns angesehen, wie Sie ein einfaches Objekt wie einen Kunden mit Eigenschaften wie Vorname<\/b>, Nachname <\/b>und Geburtsdatum <\/b>in den Textfeldern eines WPF-Fensters anzeigen. Außerdem haben Sie dort erfahren, wie Sie die Daten in beiden Richtungen synchron halten können.<\/p>\n

Nun wollen wir ein Listenobjekt wie beispielsweise eine Col-lection <\/b>mit mehreren Kunde<\/b>-Objekten füllen und diese samt ausgewählter Eigenschaften in verschiedenen Listen-Steuerelementen von WPF anzeigen – zum Beispiel im DataGrid<\/b>, in der ComboBox<\/b>, in der ListBox <\/b>oder in der ListView<\/b>. Welche Steuerelemente für die Darstellung einer Auflistung infrage kommen, hängt übrigens allein davon ab, ob diese von der Klasse ItemsControl <\/b>abgeleitet sind. Was die Listen-Objekte angeht, deren Inhalt wir im Listen-Steuerelement abbilden wollen, so müssen diese lediglich die IEnumerable<\/b>-Schnittstelle implementieren.<\/p>\n

Ob ein Steuerelement die Klasse ItemsControl <\/b>als Basistyp verwendet, können Sie beispielsweise im Objektkatalog nachlesen. Suchen Sie dort einfach nach dem gewünschten Steuerelement und schauen sich im linken Bereich die Basistypen des Steuerelements an. In Bild 1 finden Sie beispielsweise ItemsControl <\/b>als Basistyp für das ComboBox<\/b>-Steuerelement vor.<\/p>\n

\"Prüfen,<\/p>\n

Bild 1: Prüfen, ob ein Steuerelement zur Darstellung von Listen geeignet ist<\/span><\/b><\/p>\n

Der Objektkatalog hilft auch dabei, die als Datenquelle für ein Listen-Steuerelement infrage kommenden Klassen zu identifizieren. In Bild 2 etwa erkennen wir, dass das Collection<\/b>-Objekt die Schnittstelle IEnumerable <\/b>implementiert und somit als Datenquelle taugt.<\/p>\n

\"Untersuchen<\/p>\n

Bild 2: Untersuchen einer Klasse auf Listen-Fähigkeit<\/span><\/b><\/p>\n

Liste mit Kunden füllen<\/h2>\n

Schauen wir uns zunächst an, wie wir ein Listen-Objekt mit einigen verschiedenen Kunde<\/b>-Objekten füllen. Da wir in diesem Fall wissen, dass wir immer den gleichen Objekttyp zum Listen-Objekt hinzufügen möchten, verwenden wir nicht die üblicherweise verwendeten Listen-Typen wie Collection <\/b>oder ArrayList<\/b>. Diese haben nämlich den Nachteil, dass sie beliebige Objekte aufnehmen können und dadurch beim Zugriff immer eine Typkonvertierung nötig ist.<\/p>\n

Im Gegensatz dazu gibt es die typsicheren generischen Auflistungsklassen, bei denen man direkt bei der Deklaration angibt, welchen Typ die aufzunehmenden Elemente haben. Dieser wird dabei in spitzen Klammern hinter dem Schlüsselwort für die zu verwendende Auflistungsklasse angegeben. In unserem Beispiel wollen wir eine Methode namens GetKunden <\/b>verwenden, um eine generische Auflistungsklasse des Typs List <\/b>mit Elementen des Typs Kunde <\/b>zu füllen und zurückzugeben.<\/p>\n

Um die generische Klasse List <\/b>zu verwenden, benötigen wir die Klasse System.Collections.Generic<\/b>, die wir mit folgender Anweisung bereitstellen:<\/p>\n

using System.Collections.Generic;<\/pre>\n
Die Methode GetKunden<\/b> finden Sie in Listing 1. Nach dem Deklarieren und Initialisieren des List<\/b>-Objekts kunden <\/b>fügt die Methode mit der Add<\/b>-Methode nacheinander drei neue Objekte des Typs Kunde <\/b>hinzu. Die Definition der Klasse Kunde <\/b>entnehmen Sie dem Beispielprojekt (siehe Kunde.cs<\/b>), eine Beschreibung dieser Klasse liefert der Artikel WPF-Datenbindung: Einfache Objekte<\/b>.<\/p>\n
private List<Kunde> GetKunden() {\r\n     List<Kunde> kunden = new List<Kunde>();\r\n     kunden.Add(new Kunde { Vorname = \"André\", Nachname = \"Minhorst\", Geburtsdatum = new DateTime(1971, 1, 23) });\r\n     kunden.Add(new Kunde { Vorname = \"Klaus\", Nachname = \"Müller\", Geburtsdatum = new DateTime(1981, 2, 3) });\r\n     kunden.Add(new Kunde { Vorname = \"Barbara\", Nachname = \"Schmitz\", Geburtsdatum = new DateTime(1976, 3, 4) });\r\n     return kunden;\r\n}<\/pre>\n
Listing 1: Füllen einer generischen Liste mit Kunde-Objekten<\/span><\/b><\/p>\n
Die Methode GetKunden <\/b>testen wir mit einer kleinen Methode, die durch die Schaltfläche btnListenelementeAusgeben <\/b>unseres Beispielfensters ListeBinden.xaml <\/b>ausgelöst wird (Code siehe Listing 2). Die Methode durchläuft die Kunde<\/b>-Objekte der mit GetKunden <\/b>gelieferten generischen Liste in einer foreach<\/b>-Schleife und stellt damit eine Zeichenkette zusammen, welche Vorname, Nachname und Geburtsdatum der Kunden enthält.<\/p>\n
private void btnListenelementeAusgeben_Click(object sender, RoutedEventArgs e) {\r\n     List<Kunde> kunden = GetKunden();\r\n     string strKunden = \"\";\r\n     foreach(Kunde kunde in kunden) {\r\n         strKunden += \"\\n\" + kunde.Vorname + \" \" + kunde.Nachname + \" \" + kunde.Geburtsdatum.ToShortDateString();\r\n     }\r\n     MessageBox.Show(\"Kunden:\" + strKunden);\r\n}<\/pre>\n
Listing 2: Testen der Methode GetKunden<\/span><\/b><\/p>\n
Die Zeichenkette gibt die Methode dann per MessageBox <\/b>auf der Benutzeroberfläche aus (siehe Bild 3).<\/p>\n
\"Ausgabe<\/p>\n
Bild 3: Ausgabe der Daten einer Klasse<\/span><\/b><\/p>\n
Liste an ListBox binden<\/h2>\n
Wenn wir einmal eine Auflistung mit den gewünschten Objekten gefüllt haben, ist die Anzeige in einem Listen-Steuer-element nicht mehr besonders kompliziert. Wir wollen es zunächst mit einem ListBox<\/b>-Steuerelement probieren.<\/p>\n
Dazu fügen Sie zum Grid des Fensters wie in Listing 3 ein Label<\/b>– und ein ListBox<\/b>-Element hinzu.<\/p>\n
<Grid>\r\n     <Grid.ColumnDefinitions>\r\n         <ColumnDefinition Width=\"60\" \/>\r\n         <ColumnDefinition Width=\"*\" \/>\r\n     <\/Grid.ColumnDefinitions>\r\n     <Grid.RowDefinitions>\r\n         <RowDefinition Height=\"30\" \/>\r\n         <RowDefinition Height=\"130\" \/>\r\n         <RowDefinition Height=\"30\" \/>\r\n     <\/Grid.RowDefinitions>\r\n     <StackPanel Orientation=\"Horizontal\" Grid.Row=\"0\" Grid.Column=\"0\" Grid.ColumnSpan=\"2\">\r\n         <Button Content=\"Listenelemente ausgeben\" Name=\"btnListenelementeAusgeben\" Margin=\"5,5,5,5\" \r\n             Click=\"btnListenelementeAusgeben_Click\"\/>\r\n     <\/StackPanel>\r\n     <Label Content=\"Kunden:\" Grid.Row=\"1\" Grid.Column=\"0\" \/>\r\n     <ListBox x:Name=\"lstKunden\" Margin=\"5,5,5,5\" VerticalAlignment=\"Top\" Grid.Row=\"1\" Grid.Column=\"1\" \/>\r\n<\/Grid><\/pre>\n
Listing 3: Definition des Grids mit dem ListBox-Steuerelement<\/span><\/b><\/p>\n
Für das ListBox<\/b>-Steuerelement legen wir vorerst keine weiteren Eigenschaften fest. Das Füllen erledigen wir mit zwei Anweisungen, die beim Öffnen des Fensters ausgeführt werden und daher in der Konstruktor-Methode der Klasse ListeBinden.xaml.cs <\/b>landen.<\/p>\n
Die erste Anweisung stellt die Eigenschaft ItemsSource <\/b>auf die Methode GetKunden <\/b>ein, die zweite erklärt das Feld Nachname <\/b>zu dem Feld, das im Listenfeld angezeigt werden soll:<\/p>\n
public ListeBinden() {\r\n     InitializeComponent();\r\n     lstKunden.ItemsSource = GetKunden();\r\n     lstKunden.DisplayMemberPath = \"Nachname\";\r\n}<\/pre>\n
Das Ergebnis sieht schon einmal den Erwartungen entsprechend aus, wie Bild 4 zeigt.<\/p>\n
\"Anzeigen<\/p>\n
Bild 4: Anzeigen von Kunden in einer ListBox<\/span><\/b><\/p>\n
Gewähltes Objekt anzeigen<\/h2>\n
Zunächst wollen wir uns ansehen, wie wir die Inhalte des aktuell gewählten Eintrags des ListBox<\/b>-Steuerelements im Fenster anzeigen können. Dazu fügen wir zunächst drei Textfelder zu jeweils einer neuen Zeile im Grid hinzu.<\/p>\n
Diese Textfelder binden wir gleich über einen speziellen Wert für das Attribut Text <\/b>an ein Feld des aktuell in der ListBox <\/b>ausgewählten Objekts, für das Textfeld txtVorname <\/b>beispielsweise wie folgt:<\/p>\n
<TextBox x:Name=\"txtVorname\" \r\n     Text=\"{Binding Path=Vorname}\" ... \/><\/pre>\n
Das allein hilft allerdings noch nicht, da das aktuell ausgewählte Objekt im ListBox<\/b>-Steuerelement noch als DataContext <\/b>angegeben werden muss. Wenn Sie nur ein einziges Textfeld an das Objekt im ListBox<\/b>-Steuerelement binden wollten, könnten Sie das Attribut DataContext <\/b>gleich dem entsprechenden TextBox<\/b>-Steuerelement hinzufügen:<\/p>\n
<TextBox DataContext=\"{Binding ElementName=lstKunden,     Path=SelectedItem}\" x:Name=\"txtVorname\"     Text=\"{Binding Path=Vorname}\" ... \/><\/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