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

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

• LINQ
• Inleiding tot LINQ in Visual Basic
• Join-component
• Groepsdeelnamecomponent
• Van component
• Where-component
• Query's
• Gegevenstransformaties met LINQ (C#)