Gewusst wie: Kombinieren von Daten mit LINQ mithilfe von Joins (Visual Basic)

Artikel
07/20/2011

Visual Basic stellt die Abfrageklauseln Join und Group Join bereit, mit denen Sie die Inhalte mehrerer Auflistungen auf Grundlage gemeinsamer Werte kombinieren können. Diese Werte werden als Schlüsselwerte bezeichnet. Mit relationalen Datenbanken vertraute Entwickler erkennen, dass die Join-Klausel einem INNER JOIN und die Group Join-Klausel praktisch einem LEFT OUTER JOIN entspricht.

In den Beispielen dieses Themas werden einige Möglichkeiten zum Kombinieren von Daten mit den Abfrageklauseln Join und Group Join veranschaulicht.

Erstellen eines Projekts und Hinzufügen von Beispieldaten

So erstellen Sie ein Projekt mit Beispieldaten und -typen

Um die Beispiele dieses Themas auszuführen, öffnen Sie Visual Studio und fügen ein neues Visual Basic-Konsolenanwendungsprojekt hinzu. Doppelklicken Sie auf die von Visual Basic erstellte Datei Module1.vb.

In den Beispielen dieses Themas werden die Typen Person und Pet und Daten aus den folgenden Codebeispielen verwendet. Kopieren Sie diesen Code in das von Visual Basic erstellte Standardmodul Module1.

Private _people As List(Of Person)
Private _pets As List(Of Pet)

Function GetPeople() As List(Of Person)
    If _people Is Nothing Then CreateLists()
    Return _people
End Function

Function GetPets(ByVal people As List(Of Person)) As List(Of Pet)
    If _pets Is Nothing Then CreateLists()
    Return _pets
End Function

Private Sub CreateLists()
    Dim pers As Person

    _people = New List(Of Person)
    _pets = New List(Of Pet)

    pers = New Person With {.FirstName = "Magnus", .LastName = "Hedlund"}
    _people.Add(pers)
    _pets.Add(New Pet With {.Name = "Daisy", .Owner = pers})

    pers = New Person With {.FirstName = "Terry", .LastName = "Adams"}
    _people.Add(pers)
    _pets.Add(New Pet With {.Name = "Barley", .Owner = pers})
    _pets.Add(New Pet With {.Name = "Boots", .Owner = pers})
    _pets.Add(New Pet With {.Name = "Blue Moon", .Owner = pers})

    pers = New Person With {.FirstName = "Charlotte", .LastName = "Weiss"}
    _people.Add(pers)
    _pets.Add(New Pet With {.Name = "Whiskers", .Owner = pers})

    ' Add a person with no pets for the sake of Join examples.
    _people.Add(New Person With {.FirstName = "Arlene", .LastName = "Huff"})

    pers = New Person With {.FirstName = "Don", .LastName = "Hall"}
    ' Do not add person to people list for the sake of Join examples.
    _pets.Add(New Pet With {.Name = "Spot", .Owner = pers})

    ' Add a pet with no owner for the sake of Join examples.
    _pets.Add(New Pet With {.Name = "Unknown", 
                            .Owner = New Person With {.FirstName = String.Empty, 
                                                      .LastName = String.Empty}})
End Sub


...


Class Person
    Public Property FirstName As String
    Public Property LastName As String
End Class

Class Pet
    Public Property Name As String
    Public Property Owner As Person
End Class

Ausführen eines inneren Joins mithilfe der Join-Klausel

Ein INNER JOIN kombiniert Daten aus zwei Auflistungen. Es werden die Elemente eingeschlossen, bei denen die angegebenen Schlüsselwerte übereinstimmen. Alle Elemente der beiden Auflistungen, für die es in der jeweils anderen Auflistung kein passendes Element gibt, werden ausgeschlossen.

LINQ stellt in Visual Basic zwei Optionen zum Ausführen eines INNER JOIN bereit: einen impliziten Join und einen expliziten Join.

Bei einem impliziten Join werden die zu verknüpfenden Auflistungen in einer From-Klausel angegeben und die entsprechenden Schlüsselfelder in einer Where-Klausel identifiziert. Visual Basic verknüpft die beiden Auflistungen implizit auf Grundlage der angegebenen Schlüsselfelder.

Einen expliziten Join können Sie mit der Join-Klausel angeben, wenn Sie genau festlegen möchten, welche Schlüsselfelder in dem Join verwendet werden sollen. In diesem Fall kann weiterhin eine Where-Klausel verwendet werden, um die Abfrageergebnisse zu filtern.

So führen Sie einen inneren Join mithilfe der Join-Klausel aus

Fügen Sie Ihrem Projekt im Modul Module1 den folgenden Code hinzu, um Beispiele sowohl für einen impliziten als auch für einen expliziten inneren Join zu erhalten.

Sub InnerJoinExample()
    ' Create two lists.
    Dim people = GetPeople()
    Dim pets = GetPets(people)

    ' Implicit Join.
    Dim petOwners = From pers In people, pet In pets
                    Where pet.Owner Is pers
                    Select pers.FirstName, PetName = pet.Name

    ' Display grouped results.
    Dim output As New System.Text.StringBuilder
    For Each pers In petOwners
        output.AppendFormat(
          pers.FirstName & ":" & vbTab & pers.PetName & vbCrLf)
    Next

    Console.WriteLine(output)

    ' Explicit Join.
    Dim petOwnersJoin = From pers In people
                        Join pet In pets
                        On pet.Owner Equals pers
                        Select pers.FirstName, PetName = pet.Name

    ' Display grouped results.
    output = New System.Text.StringBuilder()
    For Each pers In petOwnersJoin
        output.AppendFormat(
          pers.FirstName & ":" & vbTab & pers.PetName & vbCrLf)
    Next

    Console.WriteLine(output)

    ' Both queries produce the following output:
    '
    ' Magnus:    Daisy
    ' Terry:     Barley
    ' Terry:     Boots
    ' Terry:     Blue Moon
    ' Charlotte: Whiskers
End Sub

Ausführen eines linken äußeren Joins mithilfe der Group Join-Klausel

Mit LEFT OUTER JOIN werden alle Elemente der Auflistung auf der linken Seite des Joins und nur die passenden Werte der Auflistung auf der rechten Seite des Joins eingeschlossen. Die Elemente der Auflistung auf der rechten Seite des Joins, für die es in der Auflistung auf der linken Seite des Joins kein passendes Element gibt, werden aus dem Abfrageergebnis ausgeschlossen.

Die Group Join-Klausel verhält sich praktisch wie ein LEFT OUTER JOIN. Der Unterschied zwischen einem normalen LEFT OUTER JOIN und der Rückgabe der Group Join-Klausel besteht darin, dass die Ergebnisse aus der Auflistung auf der rechten Seite des Joins bei der Group Join-Klausel für jedes Element der Auflistung auf der linken Seite des Joins gruppiert werden. In einer relationalen Datenbank wird bei einem LEFT OUTER JOIN ein nicht gruppiertes Ergebnis zurückgegeben, bei dem jedes Element des Abfrageergebnisses passende Elemente aus beiden Auflistungen des Joins enthält. In diesem Fall werden die Elemente der Auflistung auf der linken Seite des Joins für jedes passende Element der Auflistung auf der rechten Seite des Joins wiederholt. Sie werden diese Darstellung deutlicher erkennen, wenn Sie das nächste Verfahren durchführen.

Sie können die Ergebnisse einer Group Join-Abfrage ohne Gruppierung abrufen, indem Sie die Abfrage so erweitern, dass für jedes gruppierte Abfrageergebnis ein Element zurückgegeben wird. Zu diesem Zweck müssen Sie sicherstellen, dass Sie die Abfrage mithilfe der DefaultIfEmpty-Methode der gruppierten Auflistung ausführen. Dadurch wird sichergestellt, dass im Abfrageergebnis auch Elemente der Auflistung auf der linken Seite des Joins eingeschlossen werden, wenn es keine passenden Ergebnisse in der Auflistung auf der rechten Seite gibt. Sie können Ihrer Abfrage Code zum Bereitstellen eines Standardergebnisses hinzufügen, wenn es in der Auflistung auf der rechten Seite des Joins keinen passenden Wert gibt.

So führen Sie einen linken äußeren Join mithilfe der Group Join-Klausel aus

Fügen Sie Ihrem Projekt im Modul Module1 den folgenden Code hinzu, um Beispiele sowohl für einen gruppierten als auch für einen nicht gruppierten linken äußeren Join zu erhalten.

Sub LeftOuterJoinExample()
    ' Create two lists.
    Dim people = GetPeople()
    Dim pets = GetPets(people)

    ' Grouped results.
    Dim petOwnersGrouped = From pers In people
                           Group Join pet In pets
                             On pers Equals pet.Owner
                           Into PetList = Group
                           Select pers.FirstName, pers.LastName,
                                  PetList

    ' Display grouped results.
    Dim output As New System.Text.StringBuilder
    For Each pers In petOwnersGrouped
        output.AppendFormat(pers.FirstName & ":" & vbCrLf)
        For Each pt In pers.PetList
            output.AppendFormat(vbTab & pt.Name & vbCrLf)
        Next
    Next

    Console.WriteLine(output)
    ' This code produces the following output:
    '
    ' Magnus:
    '     Daisy
    ' Terry:
    '     Barley
    '     Boots
    '     Blue Moon
    ' Charlotte:
    '     Whiskers
    ' Arlene:

    ' "Flat" results.
    Dim petOwners = From pers In people
                    Group Join pet In pets On pers Equals pet.Owner
                    Into PetList = Group
                    From pet In PetList.DefaultIfEmpty()
                    Select pers.FirstName, pers.LastName,
                           PetName =
                             If(pet Is Nothing, String.Empty, pet.Name)


    ' Display "flat" results.
    output = New System.Text.StringBuilder()
    For Each pers In petOwners
        output.AppendFormat(
          pers.FirstName & ":" & vbTab & pers.PetName & vbCrLf)
    Next

    Console.WriteLine(output.ToString())
    ' This code produces the following output:
    '
    ' Magnus:       Daisy
    ' Terry:        Barley
    ' Terry:        Boots
    ' Terry:        Blue Moon
    ' Charlotte:    Whiskers
    ' Arlene:     
End Sub

Ausführen eines Joins mithilfe eines zusammengesetzten Schlüssels

Mit dem And-Schlüsselwort können Sie in einer Join-Klausel oder einer Group Join-Klausel mehrere zu verwendende Schlüsselfelder zum Vergleichen der Werte aus den zu verknüpfenden Auflistungen festlegen. Mit dem And-Schlüsselwort geben Sie an, dass für die zu verknüpfenden Elemente alle angegebenen Schlüsselfelder übereinstimmen müssen.

So führen Sie einen Join mithilfe eines zusammengesetzten Schlüssels aus

Fügen Sie Ihrem Projekt im Modul Module1 den folgenden Code hinzu, um Beispiele für einen Join anzuzeigen, der einen zusammengesetzten Schlüssel verwendet.

Sub CompositeKeyJoinExample()
    ' Create two lists.
    Dim people = GetPeople()
    Dim pets = GetPets(people)

    ' Implicit Join.
    Dim petOwners = From pers In people
                    Join pet In pets On
                      pet.Owner.FirstName Equals pers.FirstName And
                      pet.Owner.LastName Equals pers.LastName
                Select pers.FirstName, PetName = pet.Name

        ' Display grouped results.
    Dim output As New System.Text.StringBuilder
    For Each pers In petOwners
        output.AppendFormat(
          pers.FirstName & ":" & vbTab & pers.PetName & vbCrLf)
    Next

    Console.WriteLine(output)
    ' This code produces the following output:
    '
    ' Magnus:    Daisy
    ' Terry:     Barley
    ' Terry:     Boots
    ' Terry:     Blue Moon
    ' Charlotte: Whiskers
End Sub

Ausführen des Codes

So fügen Sie Code hinzu, um die Beispiele auszuführen

Ersetzen Sie in Ihrem Projekt im Modul Module1 Sub Main durch den folgenden Code, um die Beispiele dieses Themas auszuführen.
```
Sub Main()
    InnerJoinExample()
    LeftOuterJoinExample()
    CompositeKeyJoinExample()

    Console.ReadLine()
End Sub
```
Drücken Sie F5, um die Beispiele auszuführen.

Siehe auch

Änderungsprotokoll

Datum

Versionsgeschichte

Grund

März 2011

Die Position von Ausgabekommentaren in einem Beispiel wurde geändert, und einem anderen Beispiel wurde einen Ausgabekommentar hinzugefügt.

Kundenfeedback.