Procedura: Combinare dati con LINQ utilizzando join (Visual Basic)How to: Combine Data with LINQ by Using Joins (Visual Basic)

Visual Basic fornisce il Join e Group Join clausole che consentono di combinare i contenuti di più raccolte in base ai valori comuni tra le raccolte di query.Visual Basic provides the Join and Group Join query clauses to enable you to combine the contents of multiple collections based on common values between the collections. Questi valori sono dette chiave valori.These values are known as key values. Verranno considerati dagli sviluppatori ha familiari con concetti relativi ai database relazionali di Join clausola come un INNER JOIN e Group Join clausola come, in effetti, un LEFT OUTER JOIN.Developers familiar with relational database concepts will recognize the Join clause as an INNER JOIN and the Group Join clause as, effectively, a LEFT OUTER JOIN.

Gli esempi in questo argomento illustrano alcuni modi per combinare dati utilizzando il Join e Group Join clausole di query.The examples in this topic demonstrate a few ways to combine data by using the Join and Group Join query clauses.

Creare un progetto e aggiungere dati di esempioCreate a Project and Add Sample Data

Per creare un progetto che contiene i tipi e i dati di esempioTo create a project that contains sample data and types

  1. Per eseguire gli esempi in questo argomento, aprire Visual Studio e aggiungere un nuovo progetto di applicazione Console Visual Basic.To run the samples in this topic, open Visual Studio and add a new Visual Basic Console Application project. Fare doppio clic sul file Module1.vb creato da Visual Basic.Double-click the Module1.vb file created by Visual Basic.

  2. Gli esempi in questo argomento viene utilizzato il Person e Pet tipi e i dati di esempio di codice seguente.The samples in this topic use the Person and Pet types and data from the following code example. Copiare questo codice nel valore predefinito Module1 modulo è stato creato da Visual Basic.Copy this code into the default Module1 module created by 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 JoinPerform an Inner Join by Using the Join Clause

Un INNER JOIN vengono combinati i dati dalle due raccolte.An INNER JOIN combines data from two collections. Vengono inclusi gli elementi per cui i valori di chiave specificati corrispondono.Items for which the specified key values match are included. Sono esclusi tutti gli elementi da una qualsiasi raccolta che non è un elemento corrispondente in altro insieme.Any items from either collection that do not have a matching item in the other collection are excluded.

In Visual Basic LINQ sono disponibili due opzioni per l'esecuzione di un INNER JOIN: un join implicito e un join esplicito.In Visual Basic, LINQ provides two options for performing an INNER JOIN: an implicit join and an explicit join.

Specifica di un join implicito le raccolte da includere in un From clausola e identifica i campi chiave corrispondenti in un Where clausola.An implicit join specifies the collections to be joined in a From clause and identifies the matching key fields in a Where clause. Visual Basic crea un join in modo implicito le due raccolte in base ai campi di chiave specificati.Visual Basic implicitly joins the two collections based on the specified key fields.

È possibile specificare un join esplicito utilizzando il Join clausola quando si desidera essere specifici quali campi chiave per l'utilizzo del join.You can specify an explicit join by using the Join clause when you want to be specific about which key fields to use in the join. In questo caso, un Where clausola può ancora essere utilizzata per filtrare i risultati della query.In this case, a Where clause can still be used to filter the query results.

Eseguire un Inner Join usando la clausola JoinTo perform an Inner Join by using the Join clause

  1. Aggiungere il codice seguente per il Module1 modulo nel progetto per vedere esempi di inner join sia impliciti ed espliciti.Add the following code to the Module1 module in your project to see examples of both an implicit and explicit 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
    

Eseguire un Left Outer Join con la clausola Group JoinPerform a Left Outer Join by Using the Group Join Clause

LEFT OUTER JOIN include tutti gli elementi dalla raccolta a sinistra del join e solo i corrispondenti valori dalla raccolta a destra del join.A LEFT OUTER JOIN includes all the items from the left-side collection of the join and only matching values from the right-side collection of the join. Tutti gli elementi dalla raccolta a destra del join che non è un elemento corrispondente nella raccolta a sinistra vengono esclusi dal risultato della query.Any items from the right-side collection of the join that do not have a matching item in the left-side collection are excluded from the query result.

Il Group Join clausola esegue, in effetti, un LEFT OUTER JOIN.The Group Join clause performs, in effect, a LEFT OUTER JOIN. La differenza tra ciò che è in genere noto come un LEFT OUTER JOIN e quali le Group Join la clausola restituisce è che il Group Join risultati del nodo gruppi clausola dalla raccolta a destra del join per ogni elemento nella raccolta a sinistra.The difference between what is typically known as a LEFT OUTER JOIN and what the Group Join clause returns is that the Group Join clause groups results from the right-side collection of the join for each item in the left-side collection. In un database relazionale, un LEFT OUTER JOIN restituisce un risultato non raggruppato nella quale restituire ogni elemento della query contiene gli elementi corrispondenti da entrambe le raccolte nel join.In a relational database, a LEFT OUTER JOIN returns an ungrouped result in which each item in the query result contains matching items from both collections in the join. In questo caso, gli elementi dalla raccolta a sinistra del join vengono ripetuti per ogni elemento corrispondente dalla raccolta a destra.In this case, the items from the left-side collection of the join are repeated for each matching item from the right-side collection. Verrà visualizzato come appare quando si completa la procedura successiva.You will see what this looks like when you complete the next procedure.

È possibile recuperare i risultati di una Group Join query come risultato non raggruppato mediante l'estensione di query per restituire un elemento per ogni risultato della query raggruppati.You can retrieve the results of a Group Join query as an ungrouped result by extending your query to return an item for each grouped query result. A tale scopo, è necessario assicurarsi che si esegue una query nella DefaultIfEmpty metodo della raccolta raggruppata.To accomplish this, you have to ensure that you query on the DefaultIfEmpty method of the grouped collection. Ciò garantisce che gli elementi della raccolta lato sinistro del join sono ancora incluse nel risultato della query, anche se non hanno risultati corrispondenti dalla raccolta a destra.This ensures that items from the left-side collection of the join are still included in the query result even if they have no matching results from the right-side collection. È possibile aggiungere codice alla query per fornire un valore predefinito quando è presente alcun valore corrispondente dalla raccolta a destra del join.You can add code to your query to provide a default result value when there is no matching value from the right-side collection of the join.

Per eseguire un Left Outer Join con la clausola Group JoinTo perform a Left Outer Join by using the Group Join clause

  1. Aggiungere il codice seguente per il Module1 modulo nel progetto per visualizzare un esempio di un left outer join raggruppati e un left outer join non raggruppati.Add the following code to the Module1 module in your project to see examples of both a grouped left outer join and an ungrouped 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
    

Eseguire un Join usando una chiave compostaPerform a Join by Using a Composite Key

È possibile usare la And parola chiave in un Join o Group Join clausola per identificare più campi di chiave da usare durante l'associazione di valori dalle raccolte da unire in join.You can use the And keyword in a Join or Group Join clause to identify multiple key fields to use when matching values from the collections being joined. Il And parola chiave specifica che tutti specificati devono corrispondere ai campi chiave per gli elementi da unire.The And keyword specifies that all specified key fields must match for items to be joined.

Per eseguire un Join usando una chiave compostaTo perform a Join by using a composite key

  1. Aggiungere il codice seguente per il Module1 modulo nel progetto per vedere esempi di join che utilizza una chiave composta.Add the following code to the Module1 module in your project to see examples of a join that uses a composite key.

    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 codiceRun the Code

Per aggiungere il codice per eseguire gli esempiTo add code to run the examples

  1. Sostituire il Sub Main nella Module1 modulo nel progetto con il codice seguente per eseguire gli esempi in questo argomento.Replace the Sub Main in the Module1 module in your project with the following code to run the examples in this topic.

    Sub Main()
        InnerJoinExample()
        LeftOuterJoinExample()
        CompositeKeyJoinExample()
    
        Console.ReadLine()
    End Sub
    
  2. Premere F5 per eseguire gli esempi.Press F5 to run the examples.

Vedere ancheSee also