Freigeben über

Vorgehensweise: Kombinieren von Daten mit LINQ mithilfe von Verknüpfungen (Visual Basic)

Visual Basic stellt die Join Klauseln und Group Join Abfrageklauseln bereit, mit denen Sie den Inhalt mehrerer Auflistungen basierend auf gemeinsamen Werten zwischen den Auflistungen kombinieren können. Diese Werte werden als Schlüsselwerte bezeichnet. Entwickler, die mit relationalen Datenbankkonzepten vertraut sind, erkennen die Join Bedingung als INNER JOIN und die Group Join Bedingung effektiv als LEFT OUTER JOIN.

Die Beispiele in diesem Thema veranschaulichen einige Möglichkeiten zum Kombinieren von Daten mithilfe der Join Klauseln und Group Join Abfrageklauseln.

Erstellen eines Projekts und Hinzufügen von Beispieldaten

So erstellen Sie ein Projekt, das Beispieldaten und -typen enthält

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

  2. In den Beispielen in diesem Thema werden die Person Typen und Pet Daten aus dem folgenden Codebeispiel verwendet. Kopieren Sie diesen Code in das Standardmodul, Module1 das von Visual Basic erstellt wurde.

    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 einer inneren Verknüpfung mithilfe der Join-Klausel

Ein "INNER JOIN" kombiniert die Daten aus zwei Sammlungen. Elemente, für die die angegebenen Schlüsselwerte übereinstimmen, sind enthalten. Alle Elemente aus beiden Auflistungen, die nicht über ein übereinstimmenes Element in der anderen Auflistung verfügen, werden ausgeschlossen.

In Visual Basic bietet LINQ zwei Optionen zum Ausführen einer INNER JOIN: eine implizite Verknüpfung und eine explizite Verknüpfung.

Eine implizite Verknüpfung gibt die Auflistungen an, die in einer From Klausel verknüpft werden sollen, und identifiziert die übereinstimmenden Schlüsselfelder in einer Where Klausel. Visual Basic verknüpft implizit die beiden Auflistungen basierend auf den angegebenen Schlüsselfeldern.

Sie können eine explizite Verknüpfung angeben, indem Sie die Join Klausel verwenden, wenn Sie spezifisch sein möchten, welche Schlüsselfelder in der Verknüpfung verwendet werden sollen. In diesem Fall kann eine Where Klausel weiterhin verwendet werden, um die Abfrageergebnisse zu filtern.

Ausführen einer inneren Verknüpfung mithilfe der Join-Klausel

  1. Fügen Sie dem Module1 Modul in Ihrem Projekt den folgenden Code hinzu, um Beispiele für eine implizite und explizite innere Verknüpfung anzuzeigen.

    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 einer linken äußeren Verknüpfung mithilfe der Gruppenbeitrittsklausel

Ein LEFT OUTER JOIN enthält alle Elemente aus der linken Auflistung des Joins und nur übereinstimmende Werte aus der rechten Auflistung des Joins. Alle Elemente aus der rechten Auflistung der Verknüpfung, die nicht über ein übereinstimmenes Element in der linken Auflistung verfügen, werden vom Abfrageergebnis ausgeschlossen.

Die Group Join-Klausel führt tatsächlich einen LEFT OUTER JOIN aus. Der Unterschied zwischen dem, was in der Regel als LEFT OUTER JOIN bezeichnet wird, und dem, was die Group Join-Klausel zurückgibt, besteht darin, dass die Group Join-Klausel die Ergebnisse aus der rechten Auflistung der Verknüpfung für jedes Element in der linken Auflistung zusammenfasst. In einer relationalen Datenbank gibt eine LEFT OUTER JOIN ein nicht gruppiertes Ergebnis zurück, in dem jedes Element im Abfrageergebnis übereinstimmende Elemente aus beiden Auflistungen in der Verknüpfung enthält. In diesem Fall werden die Elemente aus der linken Auflistung der Verknüpfung für jedes übereinstimmende Element aus der rechten Auflistung wiederholt. Sie sehen, wie dies aussieht, wenn Sie das nächste Verfahren abschließen.

Sie können die Ergebnisse einer Group Join Abfrage als nicht gruppiertes Ergebnis abrufen, indem Sie Die Abfrage erweitern, um ein Element für jedes gruppierte Abfrageergebnis zurückzugeben. Dazu müssen Sie sicherstellen, dass Sie die DefaultIfEmpty Methode der gruppierten Auflistung abfragen. Dadurch wird sichergestellt, dass Elemente aus der linken Sammlung der Verknüpfung weiterhin im Abfrageergebnis enthalten sind, auch wenn sie keine übereinstimmenden Ergebnisse aus der rechten Auflistung aufweisen. Sie können Ihrer Abfrage Code hinzufügen, um einen Standardwert für das Ergebnis bereitzustellen, wenn kein übereinstimmenden Wert aus der rechten Auflistung der Verknüpfung vorhanden ist.

Ausführen einer linken äußeren Verknüpfung mithilfe der Gruppenbeitrittsklausel

  1. Fügen Sie dem Module1 Modul in Ihrem Projekt den folgenden Code hinzu, um Beispiele für eine gruppierte linke äußere Verknüpfung und eine nicht gruppierte linke äußere Verknüpfung anzuzeigen.

    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 einer Verknüpfung mithilfe eines zusammengesetzten Schlüssels

Sie können das And Schlüsselwort in einer Join- oder Group Join-Klausel verwenden, um mehrere Schlüsselfelder zu identifizieren, die beim Vergleich von Werten aus den verknüpften Sammlungen verwendet werden sollen. Das And Schlüsselwort gibt an, dass alle angegebenen Schlüsselfelder übereinstimmen müssen, damit Elemente verknüpft werden.

Ausführen einer Verknüpfung mithilfe eines zusammengesetzten Schlüssels

  1. Fügen Sie dem Module1 Modul in Ihrem Projekt den folgenden Code hinzu, um Beispiele für eine Verknüpfung anzuzeigen, die 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

Code ausführen

Um Code zum Ausführen der Beispiele hinzuzufügen

  1. Ersetzen Sie das Sub Main im Module1 Modul in Ihrem Projekt durch den folgenden Code, um die Beispiele in diesem Thema auszuführen.

    Sub Main()
    InnerJoinExample()
    LeftOuterJoinExample()
    CompositeKeyJoinExample()

    Console.ReadLine()
End Sub

  2. Drücken Sie F5, um die Beispiele auszuführen.

Siehe auch

  • Last updated on