Delen via

Procedure: Gegevens combineren met LINQ met behulp van joins (Visual Basic)

  • Artikel

Visual Basic biedt de Join en Group Join querycomponenten waarmee u de inhoud van meerdere verzamelingen kunt combineren op basis van algemene waarden tussen de verzamelingen. Deze waarden worden sleutelwaarden genoemd. Ontwikkelaars die bekend zijn met relationele databaseconcepten herkennen de Join component als INNER JOIN en de Group Join component als een LEFT OUTER JOIN.

De voorbeelden in dit onderwerp laten een aantal manieren zien om gegevens te combineren met behulp van de Join en Group Join queryclausules.

Een project maken en voorbeeldgegevens toevoegen

Een project maken dat voorbeeldgegevens en -typen bevat

  1. Als u de voorbeelden in dit onderwerp wilt uitvoeren, opent u Visual Studio en voegt u een nieuw Visual Basic Console Application-project toe. Dubbelklik op het Module1.vb bestand dat is gemaakt door Visual Basic.

  2. In de voorbeelden in dit onderwerp worden de Person typen Pet en gegevens uit het volgende codevoorbeeld gebruikt. Kopieer deze code naar de standaardmodule Module1 die is gemaakt door Visual Basic.

    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

Een inner join uitvoeren met behulp van de join-component

Een INNER JOIN combineert gegevens uit twee verzamelingen. Items waarvoor de opgegeven sleutelwaarden overeenkomen, worden opgenomen. Alle items uit een van beide verzamelingen die geen overeenkomend item in de andere verzameling hebben, worden uitgesloten.

In Visual Basic biedt LINQ twee opties voor het uitvoeren van een INNER JOIN: een impliciete join en een expliciete join.

Een impliciete join specificeert de verzamelingen die moeten worden samengevoegd in een From component en identificeert de overeenkomende sleutelvelden in een Where component. Visual Basic voegt impliciet de twee verzamelingen samen op basis van de opgegeven sleutelvelden.

U kunt een expliciete join opgeven met behulp van de Join component als u specifiek wilt weten welke sleutelvelden in de join moeten worden gebruikt. In dit geval kan nog steeds een Where component worden gebruikt om de queryresultaten te filteren.

Een Inner Join uitvoeren met behulp van de Join-component

  1. Voeg de volgende code toe aan de Module1 module in uw project om voorbeelden te zien van zowel een impliciete als expliciete inner join.

    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

Een Left Outer Join uitvoeren met behulp van de group join-component

Een LEFT OUTER JOIN bevat alle items uit de verzameling links van de join en alleen overeenkomende waarden uit de rechterverzameling van de join. Alle items uit de rechterverzameling van de join die geen overeenkomend item in de verzameling aan de linkerkant hebben, worden uitgesloten van het queryresultaat.

De Group Join component voert in feite een LEFT OUTER JOIN uit. Het verschil tussen wat doorgaans een LEFT OUTER JOIN wordt genoemd en wat de component retourneert, is dat de Group JoinGroup Join componentgroepen het resultaat zijn van de verzameling aan de rechterkant van de join voor elk item in de verzameling aan de linkerkant. In een relationele database retourneert een LEFT OUTER JOIN een niet-gegroepeerd resultaat waarin elk item in het queryresultaat overeenkomende items uit beide verzamelingen in de join bevat. In dit geval worden de items uit de verzameling links van de join herhaald voor elk overeenkomend item uit de verzameling aan de rechterkant. U ziet hoe dit eruitziet wanneer u de volgende procedure voltooit.

U kunt de resultaten van een Group Join query ophalen als een niet-gegroepeerd resultaat door de query uit te breiden om een item te retourneren voor elk gegroepeerd queryresultaat. Hiervoor moet u ervoor zorgen dat u een query uitvoert op de DefaultIfEmpty methode van de gegroepeerde verzameling. Dit zorgt ervoor dat items uit de verzameling aan de linkerkant van de join nog steeds worden opgenomen in het queryresultaat, zelfs als ze geen overeenkomende resultaten van de verzameling aan de rechterkant hebben. U kunt code toevoegen aan uw query om een standaardresultaatwaarde op te geven wanneer er geen overeenkomende waarde is uit de verzameling rechts van de join.

Een Left Outer Join uitvoeren met behulp van de group join-component

  1. Voeg de volgende code toe aan de Module1 module in uw project om voorbeelden te zien van zowel een gegroepeerde left outer join als een niet-gegroepeerde left outer join.

    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

Een join uitvoeren met behulp van een samengestelde sleutel

U kunt het And trefwoord in een Join of Group Join component gebruiken om meerdere sleutelvelden te identificeren die moeten worden gebruikt wanneer overeenkomende waarden uit de verzamelingen die worden samengevoegd. Het And trefwoord geeft aan dat alle opgegeven sleutelvelden moeten overeenkomen voor items die moeten worden samengevoegd.

Een join uitvoeren met behulp van een samengestelde sleutel

  1. Voeg de volgende code toe aan de Module1 module in uw project om voorbeelden te zien van een join die gebruikmaakt van een samengestelde sleutel.

    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

De code uitvoeren

Code toevoegen om de voorbeelden uit te voeren

  1. Vervang de Sub Main module in uw Module1 project door de volgende code om de voorbeelden in dit onderwerp uit te voeren.

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

    Console.ReadLine()
End Sub

  2. Druk op F5 om de voorbeelden uit te voeren.

Zie ook