EF: Daten abfragen mit VB und LINQ

Lies in den Artikel rein und unten bekommst Du ein unschlagbares Angebot!

Unter 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.

Voraussetzungen

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 unserer Beispielanwendung ein DataGrid-Steuerelement hinzu. Der Code zum Füllen des DataGrid-Elements mit allen Eigenschaften aller Kunden-Elemente wie in Bild 1 sieht so aus:

Bild 1: DataGrid mit allen Kundendaten

Imports System.Collections.ObjectModel
Class MainWindow
     Private dbContext As BestellverwaltungContext
     Private _Kunden As ObservableCollection(Of Kunde)
     Public Property Kunden As ObservableCollection(Of Kunde)
         Get
             Return _Kunden
         End Get
         Set(value As ObservableCollection(Of Kunde))
             _Kunden = value
         End Set
     End Property
     Public Sub New()
         InitializeComponent()
         dbContext = New BestellverwaltungContext
         Kunden = New ObservableCollection(Of Kunde)(dbContext.Kunden)
         DataContext = Me
     End Sub
End Class

Den XAML-Code haben wir so einfach wie möglich gehalten:

<Window x:Class="MainWindow" ... Title="MainWindow" Height="450" Width="800">
     <Grid>
         <DataGrid ItemsSource="{Binding Kunden}"></DataGrid>
     </Grid>
</Window>

Die Anweisung der Konstruktor-Methode New(), die wir als Ausgangspunkt für die folgenden Beispiele nutzen, ist diese:

Kunden = New ObservableCollection(Of Kunde)(dbContext.Kunden)

Hier weisen wir der ObservableCollection mit Elementen des Typs Kunde einfach alle Kunden des Datenbankkontextes zu, also dbContext.Kunden. Statt dbContext.Kunden können wir auch die nachfolgend vorgestellten Abfrageausdrücke verwenden.

Einfache Auswahlabfrage

Die einfachste Syntax bei einer LINQ-Abfrage sieht wie folgt aus – hier noch in Zusammenhang mit unserer Anweisung:

Kunden = New ObservableCollection(Of Kunde)(From Kunde In dbContext.Kunden)

Der Einfachheit halber schauen wir uns nun noch den Teil an, den wir in eine ObservableCollection umwandeln, hier also diesen Teil:

From Kunde In dbContext.Kunden

Dies liefert alle Elemente der Kunden-Auflistung. dbContext.Kunden ist dabei die Quelle der Daten. Kunde 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.

Eine ausführlichere Schreibweise unter Einbeziehung des Select-Schlüsselworts sieht wie folgt aus und liefert wiederum das gleiche Ergebnis:

From Kunde In dbContext.Kunden Select Kunde

Daten filtern mit Where

Wenn Ihnen die bisherigen Schlüsselwörter schon von SQL bekannt vorkamen, gibt es gute Nachrichten – das Where-Schlüsselwort dürften Sie auch kennen. Dieses hängen Sie hinter die From-Anweisung an und vor der Select-Anweisung.

Das folgende Beispiel selektiert beispielsweise nur den Kunden, dessen Feld ID den Wert 1 aufweist (Ergebnis siehe Bild 2):

Bild 2: DataGrid mit dem Kunden mit dem Wert 1 im Feld ID

From Kunde In dbContext.Kunden Where Kunde.ID = 1 Select Kunde

Ersatz für den SQL-LIKE-Operator: Contains, StartsWith und EndsWith

Unter SQL haben Sie Vergleiche mit Platzhaltern wie dem Sternchen mit dem LIKE-Operator realisiert, also etwa mit SELECT * FROM tblKunden WHERE PLZ LIKE “1*”, um alle Kunden mit einer PLZ, die mit 1 beginnt, zu ermitteln.

Unter LINQ gibt es dazu die drei Operatoren Contains, StartsWith und EndsWith:

• Contains: Entspricht der Suche nach einem Ausdruck, der irgendwo im Feldinhalt vorkommen darf, also gleichbedeutend mit LIKE “**”.
• StartsWith: Sucht nach Datensätzen, deren zu durchsuchendes Feld mit dem angegebenen Ausdruck beginnt. Unter SQL wäre das LIKE “*”.
• EndsWith: Sucht nach Datensätzen, deren zu durchsuchendes Feld auf den angegebenen Ausdruck endet. Unter SQL entspricht das LIKE “*“.

Die Operatoren hängen wir an das zu durchsuchende Feld an und geben den Suchbegriff in Klammern an. Alle Kunden, deren PLZ mit 1 beginnt, ermitteln wir also mit dem folgenden Ausdruck:

From Kunde In dbContext.Kunden Where Kunde.PLZ.StartsWith("1") Select Kunde

Kriterien verknüpfen

Die Suchkriterien verknüpfen Sie einfach wie von SQL gewohnt mit den Operatoren Or und And. Kunden, deren Vorname und Nachname mit A beginnt, finden Sie beispielsweise so:

From Kunde In dbContext.Kunden Where Kunde.Vorname.StartsWith("A") Or Kunde.Nachname.StartsWith("A") Select Kunde

Daten sortieren mit Order By