Procedura: combinare dati con LINQ utilizzando join (Visual Basic)

Articolo
08/11/2011

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

Negli esempi di questo argomento vengono illustrate alcune modalità per combinare dati utilizzando le clausole query Join e Group Join.

Creare un progetto e aggiungere dati di esempio

Per creare un progetto che contiene dati e tipi di esempio

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

Negli esempi di questo utilizzo dell'argomento vengono utilizzati i tipi e i dati Person e Pet dal seguente esempio di codice. Copiare questo codice nel modulo Module1 predefinito 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 utilizzando la clausola Join

Un INNER JOIN combina i dati da due insiemi. Vengono inclusi gli elementi per i quali esiste la corrispondenza dei valori della chiave specificata . Qualsiasi elemento da un qualsiasi insieme che non ha un elemento corrispondente nell'altro insieme viene escluso.

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

Un join implicito specifica gli insiemi da combinare in una clausola From e identifica i campi chiave di corrispondenza in una clausola Where. Visual Basic implicitamente associa i due insiemi in base ai campi chiave specificati.

È possibile specificare un join esplicito utilizzando la clausola Join quando si vuole specificare quali campi chiave utilizzare nel join. In questo caso, viene comunque utilizzata una clausola Where per filtrare i risultati della query.

Per eseguire un Inner join utilizzando la clausola Join

Aggiungere il codice seguente al modulo Module1 del progetto per vedere esempi di inner join sia implicito che 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 utilizzando la clausola Group join

Un LEFT OUTER JOIN include tutti gli elementi dall'insieme di sinistra del join e solo i valori corrispondenti dall'insieme di destra del join. Qualsiasi elemento dell'insieme di destra del join che non abbia un elemento corrispondente nell'insieme di sinistra viene escluso dal risultato della query.

La clausola Group Join esegue, in effetto, un LEFT OUTER JOIN. La differenza tra quello che è in genere noto come LEFT OUTER JOIN e quello che restituisce la clausola Group Join è che la clausola Group Join raggruppa i risultati dall'insieme di destra per ogni elemento dell'insieme di sinistra. In un database relazionale, un LEFT OUTER JOIN restituisce risultati non raggruppati in cui ogni elemento nel risultato della query contiene elementi corrispondenti da entrambi gli insiemi del join. In questo caso, gli elementi dall'insieme di sinistra vengono ripetuti per ogni elemento corrispondente dell'insieme di destra. Completando la prossima procedura sarà possibile vedere un risultato di questo tipo.

È possibile recuperare i risultati di una query Group Join come risultato non raggruppato, estendendo la query in modo che restituisca un elemento per ogni risultato raggruppato della query. Per effettuare questa operazione è necessario assicurarsi di eseguire la query sul metodo DefaultIfEmpty dell'insieme raggruppato. In tal modo si è certi che gli elementi dell'insieme di sinistra del join vengano comunque inseriti nel risultato della query, anche se non hanno risultati corrispondenti nell'insieme di destra È possibile aggiungere codice alla query per fornire un valore predefinito quando non esiste un valore corrispondente nell'insieme di destra del join.

Per eseguire un Left outer join utilizzando la clausola Group join

Aggiungere il codice seguente al modulo Module1 del progetto per vedere esempi di left outer join raggruppato e 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 utilizzando una chiave composta

È possibile utilizzare la parola chiave And in una clausola Join o Group Join per identificare più campi chiave da utilizzare quando si cercano le corrispondenze tra i valori degli insiemi da unire. La parola chiave And specifica che tutti i campi chiave specificati devono corrispondere per gli elementi da unire.

Per eseguire un join utilizzando una chiave composta

Aggiungere il codice seguente al modulo Module1 nel progetto per visualizzare un esempio di join che utilizza una chiave composta.

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.

Aggiungere codice per eseguire gli esempi

Sostituire Sub Main nel modulo Module1 nel progetto con il codice seguente per eseguire gli esempi descritti in questo argomento.
```
Sub Main()
    InnerJoinExample()
    LeftOuterJoinExample()
    CompositeKeyJoinExample()

    Console.ReadLine()
End Sub
```
Premere F5 per eseguire gli esempi.

Vedere anche

Cronologia delle modifiche

Data

Cronologia

Motivo

Marzo 2011

Modificato il percorso dei commenti di output in un esempio e aggiunto un commento di output a un altro esempio.

Commenti e suggerimenti dei clienti.

Condividi tramite