![\"DataGrid](\"..\/fileadmin\/_temp_\/2019_01\/pic_166_001.png\")
<\/p>\nUnter Access waren Sie es gewöhnt, auf einfache Weise Abfragen mit der Abfrage-Entwurfsansicht zu erstellen. Ein paar Tabellen hinzufügen, die Felder auswählen, Kriterien, Sortierungen und Gruppierungen hinzufügen – fertig war die Abfrage. Gegebenenfalls haben Sie SQL-Kenntnisse und konnten SQL-Anweisungen für den Einsatz in VBA-Anweisungen von Hand schreiben. Unter VB und Entity Framework sieht das anders aus, weil wir ja nicht mehr auf Tabellen zugreifen, sondern auf Objekte. Und für die gibt es eine andere Abfragesprache, die sich direkt in den VB-Code integrieren lässt. Dieser Artikel stellt die Abfragetechnik LINQ für Visual Basic vor.<\/b><\/p>\nVoraussetzungen<\/h2>\n
Um die Beispiele dieses Artikels nachstellen zu können, benötigen das Entity Data Model aus dem Beispielprojekt aus dem Download zu diesem Artikel. Für die Beispielabfragen fügen wir dem Fenster MainWindow.xaml <\/b>unserer Beispielanwendung ein DataGrid<\/b>-Steuerelement hinzu. Der Code zum Füllen des DataGrid<\/b>-Elements mit allen Eigenschaften aller Kunden<\/b>-Elemente wie in Bild 1 sieht so aus:<\/p>\n
<\/p>\n
Bild 1: DataGrid mit allen Kundendaten<\/span><\/b><\/p>\n Den XAML-Code haben wir so einfach wie möglich gehalten:<\/p>\n Die Anweisung der Konstruktor-Methode New()<\/b>, die wir als Ausgangspunkt für die folgenden Beispiele nutzen, ist diese:<\/p>\n Hier weisen wir der ObservableCollection <\/b>mit Elementen des Typs Kunde <\/b>einfach alle Kunden des Datenbankkontextes zu, also dbContext.Kunden<\/b>. Statt dbContext.Kunden <\/b>können wir auch die nachfolgend vorgestellten Abfrageausdrücke verwenden.<\/p>\n Die einfachste Syntax bei einer LINQ-Abfrage sieht wie folgt aus – hier noch in Zusammenhang mit unserer Anweisung:<\/p>\n Der Einfachheit halber schauen wir uns nun noch den Teil an, den wir in eine ObservableCollection <\/b>umwandeln, hier also diesen Teil:<\/p>\n Dies liefert alle Elemente der Kunden<\/b>-Auflistung. dbContext.Kunden <\/b>ist dabei die Quelle der Daten. Kunde <\/b>ist eine Variable, auf die wir mit weiteren Schlüsselwörtern der Abfragesprache LINQ zugreifen können. Diese Abfrage liefert das gleiche Ergebnis wie dbKontext.Kunden<\/b>.<\/p>\n Eine ausführlichere Schreibweise unter Einbeziehung des Select<\/b>-Schlüsselworts sieht wie folgt aus und liefert wiederum das gleiche Ergebnis:<\/p>\n Wenn Ihnen die bisherigen Schlüsselwörter schon von SQL bekannt vorkamen, gibt es gute Nachrichten – das Where<\/b>-Schlüsselwort dürften Sie auch kennen. Dieses hängen Sie hinter die From<\/b>-Anweisung an und vor der Select<\/b>-Anweisung.<\/p>\n Das folgende Beispiel selektiert beispielsweise nur den Kunden, dessen Feld ID <\/b>den Wert 1 <\/b>aufweist (Ergebnis siehe Bild 2):<\/p>\n Bild 2: DataGrid mit dem Kunden mit dem Wert 1 im Feld ID<\/span><\/b><\/p>\n Unter SQL haben Sie Vergleiche mit Platzhaltern wie dem Sternchen mit dem LIKE<\/b>-Operator realisiert, also etwa mit SELECT * FROM tblKunden WHERE PLZ LIKE “1*”<\/b>, um alle Kunden mit einer PLZ, die mit 1 <\/b>beginnt, zu ermitteln.<\/p>\n Unter LINQ gibt es dazu die drei Operatoren Contains<\/b>, StartsWith <\/b>und EndsWith<\/b>:<\/p>\n Die Operatoren hängen wir an das zu durchsuchende Feld an und geben den Suchbegriff in Klammern an. Alle Kunden, deren PLZ <\/b>mit 1 <\/b>beginnt, ermitteln wir also mit dem folgenden Ausdruck:<\/p>\n Die Suchkriterien verknüpfen Sie einfach wie von SQL gewohnt mit den Operatoren Or <\/b>und And<\/b>. Kunden, deren Vorname und Nachname mit A <\/b>beginnt, finden Sie beispielsweise so:<\/p>\n Natürlich können Sie die Daten auch in beliebiger Sortierung in die ObservableCollection <\/b>füllen. Dazu verwenden wir den folgenden Abfrageausdruck, in dem wir das Order By<\/b>-Schlüsselwort gefolgt von dem zu sortierenden Feld angeben:<\/p>\n Wenn Sie nach mehreren Feldern sortieren wollen, geben Sie diese durch ein Komma voneinander getrennt hinter dem Order By<\/b>-Schlüsselwort an:<\/p>\n Hier haben wir noch nicht explizit die Sortierreihenfolge angegeben. In diesem Fall sortiert die Abfrage aufsteigend nach den angegebenen Feldern. Sie können die Sortierreihenfolge auch explizit angeben, indem Sie eines der Schlüsselwörter Ascending <\/b>(Aufsteigend<\/b>) oder Descending <\/b>(Absteigend<\/b>) hinter dem Sortierfeld angeben:<\/p>\n Im Gegensatz zu SQL, wo die Reihenfolge strikt festgelegt ist (zum Beispiel SELECT … FROM … WHERE … ORDER BY<\/b>), können Sie in LINQ etwa die Reihenfolge der Where<\/b>– und der Order By<\/b>-Klausel vertauschen. Wir empfehlen jedoch, die Reihenfolge wie unter SQL zu gestalten, um die Lesbarkeit zu erhöhen. Die folgende Abfrage, bei der wir die Order By<\/b>-Klausel vor der Where<\/b>-Klausel platziert haben, funktioniert jedoch genauso wie die mit der umgekehrten Reihenfolge:<\/p>\n Die Bezeichnung zwischen From <\/b>und In<\/b>, in unserem Fall also etwa Kunde<\/b>, können Sie beliebig wählen. Wenn Sie den Abfragecode kürzer darstellen wollen, können Sie auch einfach k <\/b>verwenden:<\/p>\n Die Select<\/b>-Anweisung haben wir in den obigen Beispielen schon ausgiebig genutzt. Allerdings haben wir mit … Select Kunde <\/b>immer einfach die kompletten Kunde<\/b>-Objekte selektiert. Das hätten wir auch erreicht, wenn wir die Select<\/b>-Klausel weggelassen hätten. Select <\/b>bietet allerdings eine Menge mehr als nur die Möglichkeit, genau die Objekte zurückzuliefern, welche die zu untersuchende Auflistung bietet, in diesem Fall die Liste der Kunde<\/b>-Objekte. In allen Fällen, in denen Sie nicht einfach die Objekte zurückliefern, die in der zu untersuchenden Auflistung enthalten sind, handelt es sich um eine sogenannte Projektion. Schauen wir uns an, wie das aussehen kann! Wenn wir beispielsweise nur die ID, den Vornamen und den Nachnamen des Kunden erhalten wollen, formulieren wir den Ausdruck wie folgt:<\/p>\n Allerdings liefert dies dann kein Objekt vom Typ Kunde <\/b>mehr zurück, was sich in einer entsprechenden Fehlermeldung bemerkbar macht (siehe Bild 3). Also spielen wir erst einmal außerhalb des DataGrids mit dieser Möglichkeit:<\/p>\n Bild 3: Fehlermeldung, wenn keine Objekte des Typs Kunde zurückgeliefert werden<\/span><\/b><\/p>\n Wir weisen also das Ergebnis, das die Eigenschaften ID<\/b>, Vorname <\/b>und Nachname <\/b>der Elemente aus dbContext.Kunden <\/b>enthält, der Variablen KundenMitName <\/b>zu. KundenMitName <\/b>wir dann zu einer Variablen des Typs DbQuery<\/b>. Auf die enthaltenen Eigenschaften können wir wie auf die Eigenschaften einer Klasse zugreifen. Im Beispiel oben durchlaufen wir diese Elemente in einer For Each<\/b>-Schleife, wobei wir das aktuelle Element der Variablen k <\/b>zuweisen. Diese hält dann die Eigenschaften ID<\/b>, Vorname <\/b>und Nachname <\/b>bereit. Diese geben wir innerhalb der Schleife mit der Debug.Print<\/b>-Anweisung im Output<\/b>-Fenster aus.<\/p>\n Wie aber zeigen wir dieses Ergebnis im DataGrid an Dieses ist ja an die Eigenschaft Kunden <\/b>der Code behind-Klasse gebunden. Wenn wir dies nicht ändern wollen, müssen wir die Informationen ID<\/b>, Vorname <\/b>und Nachname <\/b>anderweitig in Elemente des Typs Kunde <\/b>schreiben und diese dann der Auflistung zuweisen. Aber gelingt uns das Der theoretische Ansatz sieht wie folgt aus:<\/p>\n Hier weisen wir einer Variablen namens KundenMitName <\/b>das Ergebnis der Abfrage in Form von Objekten mit den Eigenschaften ID<\/b>, Vorname <\/b>und Nachname <\/b>zu. Danach wollen wir das Ergebnis der öffentlichen ObservableCollection<\/b>-Variablen Kunden <\/b>zuweisen. Das liefert allerdings den Fehler The entity or complex type ”EFAbfragnVB.Kunde” cannot be constructed in a LINQ to Entities query<\/b>. Der Grund für den Fehler ist, dass die Kunde-Entitäten nur teilweise mit den Daten aus der Datenbank gefüllt werden, was in einem nicht aktualisierbaren Zustand resultiert.<\/p>\n Also verwenden wir doch eine neue Klasse, um das neue Ergebnis zu speichern. Diese Klasse sieht wie folgt aus:<\/p>\n Den Code der Code behind-Klasse von KundenMitName.xaml <\/b>gestalten wir wie folgt, wobei wir die neue private Variable und die öffentliche Eigenschaft _KundenMitName <\/b>und KundenMitName <\/b>nennen:<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>Imports System.Collections.ObjectModel\r\nClass<\/span> MainWindow\r\n Private <\/span>dbContext As <\/span>BestellverwaltungContext\r\n Private <\/span>_Kunden As <\/span>ObservableCollection(Of Kunde)\r\n Public <\/span>Property Kunden As <\/span>ObservableCollection(Of Kunde)\r\n Get\r\n Return _Kunden\r\n End Get\r\n Set(value As <\/span>ObservableCollection(Of Kunde))\r\n _Kunden = value\r\n End Set<\/span>\r\n End Property\r\n Public <\/span>Sub New()\r\n InitializeComponent()\r\n dbContext = New<\/span> BestellverwaltungContext\r\n Kunden = New<\/span> ObservableCollection(Of Kunde)(dbContext.Kunden)\r\n DataContext = Me\r\n End Sub\r\nEnd Class<\/span><\/pre>\n<Window x:Class=\"MainWindow\" ... Title=\"MainWindow\" Height=\"450\" Width=\"800\">\r\n <Grid>\r\n <DataGrid ItemsSource=\"{Binding Kunden}\"><\/DataGrid>\r\n <\/Grid>\r\n<\/Window><\/pre>\nKunden = New<\/span> ObservableCollection(Of Kunde)(dbContext.Kunden)<\/pre>\nEinfache Auswahlabfrage<\/h2>\n
Kunden = New<\/span> ObservableCollection(Of Kunde)(From Kunde In dbContext.Kunden)<\/pre>\nFrom Kunde In dbContext.Kunden<\/pre>\n
From Kunde In dbContext.Kunden Select Kunde<\/pre>\n
Daten filtern mit Where<\/h2>\n
![\"DataGrid](\"..\/fileadmin\/_temp_\/2019_01\/pic_166_002.png\")
<\/p>\nFrom Kunde In dbContext.Kunden Where Kunde.ID = 1 Select Kunde<\/pre>\n
Ersatz für den SQL-LIKE-Operator: Contains, StartsWith und EndsWith<\/h2>\n
\n
From Kunde In dbContext.Kunden Where Kunde.PLZ.StartsWith(\"1\") Select Kunde<\/pre>\n
Kriterien verknüpfen<\/h2>\n
From Kunde In dbContext.Kunden Where Kunde.Vorname.StartsWith(\"A\") Or Kunde.Nachname.StartsWith(\"A\") Select Kunde<\/pre>\n
Daten sortieren mit Order By<\/h2>\n
From Kunde In dbContext.Kunden Order By Kunde.Nachname Select Kunde<\/pre>\n
From Kunde In dbContext.Kunden Order By Kunde.Nachname, Kunde.Vorname Select Kunde<\/pre>\n
From Kunde In dbContext.Kunden Order By Kunde.Nachname Ascending, Kunde.Vorname Descending Select Kunde<\/pre>\n
Reihenfolge der Elemente<\/h2>\n
From Kunde In dbContext.Kunden Order By Kunde.Nachname Ascending Where Kunde.Nachname.StartsWith(\"A\") Select Kunde<\/pre>\n
Die “Laufvariable”<\/h2>\n
From k In dbContext.Kunden Where k.Nachname.StartsWith(\"A\") Order By k.Nachname Ascending Select k<\/pre>\n
Zu selektierende Daten festlegen mit Select<\/h2>\n
From k In dbContext.Kunden Select k.ID, k.Vorname, k.Nachname<\/pre>\n
![\"Fehlermeldung,](\"..\/fileadmin\/_temp_\/2019_01\/pic_166_003.png\")
<\/p>\nDim <\/span>KundenMitName = From k In dbContext.Kunden Select k.ID, k.Vorname, k.Nachname\r\nFor Each k In KundenMitName\r\n Debug.Print<\/span>(k.ID.ToString() + \" \" + k.Vorname + \" \" + k.Nachname)\r\nNext<\/span><\/pre>\nDbQuery-Ergebnis in DataGrid anzeigen<\/h2>\n
Dim <\/span>KundenMitName = From k In dbContext.Kunden Select New<\/span> Kunde With<\/span> {.ID = k.ID, .Vorname = k.Vorname, .Nachname = k.Nachname}\r\nKunden = New<\/span> ObservableCollection(Of Kunde)(KundenMitName)<\/pre>\nPublic Class<\/span> KundeMitName\r\n Public <\/span>Property ID As <\/span>System.Int32\r\n <StringLength(255)>\r\n <Required>\r\n Public <\/span>Property Vorname As <\/span>System.String\r\n <StringLength(255)>\r\n <Required>\r\n Public <\/span>Property Nachname As <\/span>System.String\r\nEnd Class<\/span><\/pre>\nPublic Class<\/span> KundenMitName\r\n Private <\/span>dbContext As <\/span>BestellverwaltungContext\r\n Private <\/span>_KundenMitName As <\/span>List(Of KundeMitName)\r\n Public <\/span>Property KundenMitName As <\/span>List(Of KundeMitName)\r\n Get\r\n Return _KundenMitName\r\n End Get\r\n Set(value As <\/span>List(Of KundeMitName))\r\n _KundenMitName = value\r\n End Set<\/span>\r\n End Property<\/pre>\n
\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