{"id":55000097,"date":"2017-08-01T00:00:00","date_gmt":"2020-03-27T19:27:51","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=97"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"LINQ_to_EntitiesBeispiele_in_der_Methodensyntax","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/LINQ_to_EntitiesBeispiele_in_der_Methodensyntax\/","title":{"rendered":"LINQ to Entities-Beispiele in der Methodensyntax"},"content":{"rendered":"

LINQ to Entities ist die Abfragesprache für den Zugriff auf Daten in den Entitäten eines Entity Data Models. Im vorliegenden Artikel sehen wir uns einige Beispiele für den Zugriff per LINQ auf die Daten unserer Beispielanwendung “Bestellverwaltung” an. Dabei verwenden wir in diesem Artikel die Methoden-Syntax von LINQ.<\/b><\/p>\n

Voraussetzungen<\/h2>\n

Für die hier vorgestellten Beispiele verwenden wir das Entity Data Model der Anwendung Bestellverwaltung<\/b>. Die Ergebnisse sollen jeweils in einem DataGrid ausgegeben werden. Dazu erstellen wir ein neues Fenster namens LINQBeispiele<\/b>, dessen Entwurf wie in Bild 1 aussieht. Die Definition ist einfach gehalten. Die wichtigsten Elemente ist das Kombinationsfeld cboBeispiele<\/b>, mit dem Sie die Beispiele auswählen können, die wir anschließend per C#-Code zum Code behind-Modul hinzufügen, sowie das DataGrid<\/b>-Steuerelement db<\/b>, welches das Ergebnis der jeweiligen Abfrage anzeigen soll. Das ComboBox<\/b>-Steuerelement ist an die Eigenschaft Beispiele <\/b>gebunden und löst das Ereignis SelectionChanged <\/b>aus:<\/p>\n

\"Fenster<\/p>\n

Bild 1: Fenster zur Ausgabe der Beipiele<\/span><\/b><\/p>\n

<Window x:Class=\"Bestellverwaltung.LINQBeispiele\"\r\n         Title=\"LINQBeispiele\" Height=\"300\" Width=\"400\">\r\n     <Grid>\r\n         ... Grid-Definition ...\r\n         <StackPanel Grid.Column=\"0\" Grid.ColumnSpan=\"2\" Orientation=\"Horizontal\">\r\n             <Label Margin=\"5\">LINQ-Beispiel:<\/Label>\r\n             <ComboBox x:Name=\"cboBeispiele\" Margin=\"5\" Width=\"200\" SelectionChanged=\"cboBeispiele_SelectionChanged\" \r\n                 ItemsSource=\"{Binding Beispiele}\"><\/ComboBox>\r\n         <\/StackPanel>\r\n         <DataGrid x:Name=\"dg\" Grid.Row=\"1\" Grid.Column=\"0\" Grid.ColumnSpan=\"2\" Margin=\"5\"><\/DataGrid>\r\n         <Button x:Name=\"btnOK\" Grid.Row=\"2\" Margin=\"5\" Width=\"50\" Click=\"btnOK_Click\">OK<\/Button>\r\n     <\/Grid>\r\n<\/Window><\/pre>\n
In der Code behind-Klasse erstellen wir ein Datenbank-Kontext-Objekt mit Zugriff auf das Entity Data Model sowie eine ObservableCollection<\/b>, welche die Liste der Beispiele für das Kombinationsfeld enthält:<\/p>\n
BestellverwaltungEntities dbContext = new BestellverwaltungEntities();\r\nprivate ObservableCollection<string> beispiele;\r\npublic ObservableCollection<string> Beispiele {\r\n     get { return beispiele; }\r\n     set { beispiele = value; }\r\n}<\/pre>\n
In der Konstruktor-Methode erstellen wir die ObservableCollection <\/b>und füllen diesem mit Einträgen wie hier am Beispiel Alle Kunden<\/b>:<\/p>\n
public LINQBeispiele() {\r\n     InitializeComponent();\r\n     beispiele = new ObservableCollection<string>();\r\n     beispiele.Add(\"Alle Kunden\");\r\n     DataContext = this;\r\n}<\/pre>\n
Für das konkrete Beispiel, alle Kunden anzuzeigen, definieren wir auch wieder eine ObservableCollection<\/b>:<\/p>\n
private ObservableCollection<Kunde> kunden;\r\npublic ObservableCollection<Kunde> Kunden {\r\n     get { return kunden; }\r\n     set { kunden = value; }\r\n}<\/pre>\n
Diese wird schließlich gefüllt und angezeigt, wenn der Benutzer den Eintrag Alle Kunden <\/b>aus dem Kombinationsfeld auswählt. Dies löst das Ereignis SelectionChanged<\/b> aus, für das wir die folgende Ereignismethode hinterlegt haben:<\/p>\n
private void cboBeispiele_SelectionChanged(object sender, SelectionChangedEventArgs e) {\r\n     ComboBox cbo = (ComboBox)sender;\r\n     string beispiel = (string)cbo.SelectedItem;\r\n     switch (beispiel) {\r\n         case \"Alle Kunden\":\r\n             kunden = new ObservableCollection<Kunde>(dbContext.Kunden);\r\n             dg.ItemsSource = Kunden;\r\n             break;\r\n         default:\r\n             break;\r\n     }\r\n}<\/pre>\n
Für den Eintrag Alle Kunden <\/b>füllt die Methode nun die ObservableCollection <\/b>namens kunden <\/b>mit den über den LINQ-Ausdruck dbContext.Kunden <\/b>ermittelten Kunden. Die Eigenschaft Kunden <\/b>wird dann noch dem DataGrid dg <\/b>zugewiesen, damit dieses die Kundenliste wie in Bild 2 anzeigt. Das DataGrid ist ja flexibel, das heißt, Sie können ihm beliebige Auflistungen zuweisen. Wir fügen daher, wenn wir in den folgenden Beispielen andere ObservableCollections <\/b>als Kunden <\/b>nutzen, einfach entsprechende neue ObservableCollections hinzu und weisen die entsprechende Collection der Eigenschaft ItemsSource <\/b>des DataGrid<\/b>-Elements zu.<\/p>\n
\"Ausgabe<\/p>\n
Bild 2: Ausgabe aller Kunden des Entity Data Models<\/span><\/b><\/p>\n
Alle Elemente einer Klasse<\/h2>\n
Das erste Beispiel haben Sie ja schon kennengelernt. Um alle Elemente einer Klasse beziehungsweise Auflistung zu liefern, brauchen Sie diese einfach nur gemeinsam mit dem dbContext<\/b>-Objekt als Inhalt der neuen ObservableCollection anzugeben:<\/p>\n
kunden = new ObservableCollection<Kunde>(dbContext.Kunden);<\/pre>\n
Dies liefert alle Elemente der Kunden<\/b>-Auflistung des Entity Data Models. Alle Elemente von anderen Klassen können Sie ebenso leicht holen, dazu müssen Sie nur die entsprechende ObservableCollection <\/b>definieren und dem DataGrid zuweisen. Wenn Sie nun also alle Produkte ausgeben wollen, legen Sie erst eine neue ObservableCollection samt privater und öffentlicher Variable an:<\/p>\n
private ObservableCollection<Produkt> produkte;\r\npublic ObservableCollection<Produkt> Produkte {\r\n     get { return produkte; }\r\n     set { produkte = value; }\r\n}<\/pre>\n
Dann fügen Sie einen neuen Eintrag zur ComboBox <\/b>hinzu:<\/p>\n
public LINQBeispiele() {\r\n     ...\r\n     beispiele.Add(\"Alle Produkte\");\r\n     ...\r\n}<\/pre>\n
Schließlich noch der neue case<\/b>-Zweig in der switch<\/b>-Bedingung:<\/p>\n
case \"Alle Produkte\":\r\n     produkte = new ObservableCollection<Produkt>(dbContext.Produkte);\r\n     dg.ItemsSource = Produkte;\r\n     break;<\/pre>\n
Damit können wir uns nun in den folgenden Beispielen auf die LINQ-Ausdrücke konzentrieren.<\/p>\n
Sortieren von Elementen<\/h2>\n
Zum Sortieren nutzen wir die OrderBy<\/b>– oder die OrderByDescending<\/b>-Methode. Letztere ist für die absteigende Sortierung verantwortlich. Der folgende Ausdruck liefert alle Kunden, aufsteigend sortiert nach den Nachnamen:<\/p>\n
dbContext.Kunden.OrderBy(d => d.Nachname)<\/pre>\n
Wenn Sie die Kunden absteigend nach den Nachnamen sortieren wollen, verwenden Sie OrderByAscending<\/b>:<\/p>\n
dbContext.Kunden.OrderByDescending(d => d.Nachname)<\/pre>\n
Für Sortierungen nach verschiedenen Feldern in der gleichen Abfrage verwenden Sie OrderBy<\/b>\/OrderByDescending<\/b>– gefolgt von einem oder mehreren Aufrufen der ThenBy<\/b>\/ThenByDescending<\/b>-Methode. Wenn Sie also zuerst nach dem Nachnamen und dann nach dem Vornamen sortieren wollen, verwenden Sie den folgenden Ausdruck:<\/p>\n
dbContext.Kunden.OrderBy(d => d.Nachname).ThenBy(d => d.Vorname)<\/pre>\n
Man könnte fälschlicherweise meinen, zwei aufeinanderfolgende Aufrufe der OrderBy<\/b>-Methode würden die Aufgabe auch erledigen. Das ist aber mitnichten der Fall. Die folgende Abfrage sortiert nämlich erst nach dem Vornamen und dann nach dem Nachnamen – allerdings wird die erste Sortierung beim Ausführen der zweiten verworfen, sodass auch bei mehreren gleichen Nachnamen die Datensätze nur zufällig richtig nach dem Vornamen sortiert sein dürften:<\/p>\n
dbContext.Kunden.OrderBy(d => d.Vorname).OrderBy(d => d.Nachname)<\/pre>\n
Der folgende Ausdruck sortiert aufsteigend nach den Nachnamen und absteigend nach dem Vornamen:<\/p>\n
dbContext.Kunden.OrderBy(d => d.Nachname).ThenByDescending(d => d.Vorname)<\/pre>\n
Filtern nach einzelnen Feldern<\/h2>\n
Wenn Sie Daten etwa nach dem Inhalt eines Feldes filtern wollen, können Sie das mit der Where<\/b>-Methode erledigen. Das folgende Beispiel liefert etwa alle Kunden, deren Feld Nachname <\/b>den Wert Müller <\/b>enthält:<\/p>\n
dbContext.Kunden.Where(d => d.Nachname == \"Müller\")<\/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