Condividi tramite

Procedura: Combinare dati con LINQ tramite join (Visual Basic)

Visual Basic fornisce le Join clausole di query e Group Join per consentire di combinare il contenuto di più raccolte in base ai valori comuni tra le raccolte. Questi valori sono noti come valori chiave . Gli sviluppatori che hanno familiarità con i concetti relativi al database relazionale riconosceranno la Join clausola come INNER JOIN e la Group Join clausola come, in effetti, un LEFT OUTER JOIN.

Gli esempi in questo argomento illustrano alcuni modi per combinare i dati usando le Join clausole di query e Group Join .

Creare un progetto e aggiungere dati di esempio

Per creare un progetto contenente dati e tipi di esempio

  1. Per eseguire gli esempi in questo argomento, aprire Visual Studio e aggiungere un nuovo progetto di applicazione console di Visual Basic. Fare doppio clic sul file Module1.vb creato da Visual Basic.

  2. Gli esempi in questo argomento usano i tipi Person e i dati Pet dell'esempio di codice seguente. Copiare questo codice nel modulo predefinito Module1 creato da 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

Eseguire un inner join usando la clausola join

Inner JOIN combina i dati di due raccolte. Gli elementi per i quali i valori di chiave specificati corrispondono sono inclusi. Tutti gli elementi di una raccolta che non dispongono di un elemento corrispondente nell'altra raccolta vengono esclusi.

In Visual Basic LINQ offre due opzioni per l'esecuzione di un INNER JOIN: un join implicito e un join esplicito.

Un join implicito specifica le raccolte da unire in una From clausola e identifica i campi chiave corrispondenti in una Where clausola . Visual Basic unisce in modo implicito le due raccolte in base ai campi chiave specificati.

È possibile specificare un join esplicito usando la Join clausola quando si desidera essere specifici sui campi chiave da usare nel join. In questo caso, è comunque possibile usare una Where clausola per filtrare i risultati della query.

Per eseguire un inner join utilizzando la clausola Join

  1. Aggiungere il codice seguente al Module1 modulo nel progetto per visualizzare esempi di inner join implicito ed esplicito.

    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

Eseguire un Left Outer Join usando la clausola di Group Join

LEFT OUTER JOIN include tutti gli elementi della raccolta sul lato sinistro del join e solo i valori corrispondenti della raccolta sul lato destro del join. Tutti gli elementi della raccolta sul lato destro del join che non dispongono di un elemento corrispondente nella raccolta sul lato sinistro vengono esclusi dal risultato della query.

La Group Join clausola effettivamente esegue un LEFT OUTER JOIN. La differenza tra ciò che in genere è noto come LEFT OUTER JOIN e quello che la clausola Group JoinGroup Join restituisce è che la clausola raggruppa i risultati dalla raccolta di destra del join per ogni elemento nella raccolta di sinistra. In un database relazionale, LEFT OUTER JOIN restituisce un risultato non raggruppato in cui ogni elemento nel risultato della query contiene elementi corrispondenti di entrambe le raccolte nel join. In questo caso, gli elementi della collezione sul lato sinistro del join vengono ripetuti per ogni elemento corrispondente nella collezione sul lato destro. Vedrai com'è quando completi la procedura successiva.

È possibile recuperare i risultati di una Group Join query come risultato non raggruppato estendendo la query per restituire un elemento per ogni risultato della query raggruppata. A tale scopo, è necessario assicurarsi di eseguire una query sul DefaultIfEmpty metodo della raccolta raggruppata. Ciò garantisce che gli elementi della raccolta sul lato sinistro del join siano ancora inclusi nel risultato della query anche se non hanno risultati corrispondenti dalla raccolta sul lato destro. È possibile aggiungere codice alla query per fornire un valore di risultato predefinito quando non esiste alcun valore corrispondente dalla raccolta sul lato destro del join.

Per eseguire un Left Outer Join utilizzando la clausola Group Join

  1. Aggiungi il codice seguente al modulo Module1 del progetto per visualizzare esempi di un left outer join raggruppato e di un left outer join non raggruppato.

    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

Eseguire un join usando una chiave composita

È possibile usare la parola chiave And in una clausola Join o Group Join per identificare diversi campi chiave da utilizzare quando si confrontano i valori delle raccolte da unire. La And parola chiave specifica che tutti i campi chiave specificati devono corrispondere per gli elementi da unire.

Per eseguire un join usando una chiave composta

  1. Aggiungere il codice seguente al Module1 modulo nel progetto per visualizzare esempi di join che usa una chiave composita.

    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

Eseguire il codice

Per aggiungere codice per eseguire gli esempi

  1. Sostituire il Sub Main nel modulo Module1 del progetto con il codice seguente per eseguire gli esempi di questo argomento.

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

    Console.ReadLine()
End Sub

  2. Premere F5 per eseguire gli esempi.

Vedere anche

  • Last updated on