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

Artikel
09/02/2008

Aktualisiert: November 2007

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 _firstName As String
  Public _lastName As String

  Public Property FirstName() As String
    Get
      Return _firstName
    End Get
    Set(ByVal value As String)
      _firstName = value
    End Set
  End Property

  Public Property LastName() As String
    Get
      Return _lastName
    End Get
    Set(ByVal value As String)
      _lastName = value
    End Set
  End Property
End Class

Class Pet
  Public _name As String
  Public _owner As Person

  Public Property Name() As String
    Get
      Return _name
    End Get
    Set(ByVal value As String)
      _name = value
    End Set
  End Property

  Public Property Owner() As Person
    Get
      Return _owner
    End Get
    Set(ByVal value As Person)
      _owner = value
    End Set
  End Property
End Class

Ausführen einer inneren Verknüpfung 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: eine implizite Verknüpfung und eine explizite Verknüpfung.

Bei einer impliziten Verknüpfung 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.

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

So führen Sie eine innere Verknüpfung mithilfe der Join-Klausel aus

Fügen Sie Ihrem Projekt im Modul Module1 den folgenden Code hinzu, um Beispiele sowohl für eine implizite als auch für eine explizite innere Verknüpfung 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 einer linken äußeren Verknüpfung mithilfe der Group Join-Klausel

Mit LEFT OUTER JOIN werden alle Elemente der Auflistung auf der linken Seite der Verknüpfung und nur die passenden Werte der Auflistung auf der rechten Seite der Verknüpfung eingeschlossen. Die Elemente der Auflistung auf der rechten Seite der Verknüpfung, für die es in der Auflistung auf der linken Seite der Verknüpfung 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 der Verknüpfung bei der Group Join-Klausel für jedes Element der Auflistung auf der linken Seite der Verknüpfung 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 der Verknüpfung enthält. In diesem Fall werden die Elemente der Auflistung auf der linken Seite der Verknüpfung für jedes passende Element der Auflistung auf der rechten Seite der Verknüpfung 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 der Verknüpfung 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 der Verknüpfung keinen passenden Wert gibt.

So führen Sie eine linke äußere Verknüpfung mithilfe der Group Join-Klausel aus

Fügen Sie Ihrem Projekt im Modul Module1 den folgenden Code hinzu, um Beispiele sowohl für eine gruppierte als auch für eine nicht gruppierte linke äußere Verknüpfung 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)

  ' "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)
  ' This code produces the following output:
  '
  ' Magnus:
  '     Daisy
  ' Terry:
  '     Barley
  '     Boots
  '     Blue Moon
  ' Charlotte:
  '     Whiskers
  ' Arlene:


  ' 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())
End Sub

' This code produces the following output:
'
' Magnus:       Daisy
' Terry:        Barley
' Terry:        Boots
' Terry:        Blue Moon
' Charlotte:    Whiskers
' Arlene:

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

Fügen Sie Ihrem Projekt im Modul Module1 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)
End Sub

Ausführen des Codes

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

Ersetzen Sie in Ihrem Projekt im Modul Module1Sub 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

Freigeben über