Freigeben über


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

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

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

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

  1. 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
    
  2. Drücken Sie F5, um die Beispiele auszuführen.

Siehe auch

Referenz

Join-Klausel (Visual Basic)

Group Join-Klausel (Visual Basic)

From-Klausel (Visual Basic)

Where-Klausel (Visual Basic)

Konzepte

Einführung in LINQ in Visual Basic

Datentransformationen mit LINQ (C#)

Weitere Ressourcen

LINQ in Visual Basic

Abfragen (Visual Basic)

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