Compartilhar via


Como combinar dados a LINQ com junções (Visual Basic)

O Visual Basic provê as cláusulas de consulta Join e Group Join para que você possa combinar os conteúdos de múltiplas coleções baseado em valores comuns entre as coleções. Estes valores são conhecidos como valores chave. Desenvolvedores familiares com conceitos de bases de dados relacionais vão reconhecer a cláusula Join como um INNER JOIN e a cláusula Group Join como, efetivamente, uma LEFT OUTER JOIN.

Os exemplos neste tópico demonstram algumas maneiras de combinar dados usando as cláusulas de consulta Join e Group Join.

Crie um Projeto e Adicione Dados de Exemplo.

Criar um projeto que contém dados e tipos de exemplo.

  1. Para rodar os exemplos neste tópico, abra o Visual Studio e adicione um novo projeto de Aplicaçao de Console Visual Basic. Dê um clique duplo no arquivo Module1.vb criado pelo Visual Basic.

  2. Os exemplos neste tópico usam os tipos Person e Pet e dados do exemplo de código a seguir. Copie este código no módulo padrão Module1 criado pelo 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
    

Faça uma Inner Join usando a Cláusula Join.

Uma INNER JOIN combina dados de duas coleções. Itens para os quais a chave especificada coincide são inclusos. Quaisquer itens de uma das duas coleções que não têm um item correspondente na outra coleção são excluídos.

Em Visual Basic, LINQ provê duas opções para executar uma INNER JOIN: um join implícito e um join explícito.

Um join implícito especifica as coleções a serem juntas numa cláusula From e identifica os campos-chave correspondentes numa cláusula Where. O Visual Basic junta implicitamente as duas coleções baseado nos campos-chave especificados.

Você pode especificar um join explícito usando a cláusula Join quando você quer ser específico sobre quais campos-chave usar na join. Neste caso, uma cláusula Where pode ser usada para filtrar os resultados da consulta.

Fazer uma Inner Join usando a cláusula Join.

  • Adicione o seguinte código ao módulo Module1 em seu projeto para ver exemplos tanto de um join implícito como de um explícito.

    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
    

Faça um Left Outer Join usando a cláusula Group Join.

Um LEFT OUTER JOIN inclui todos os itens da coleção à esquerda do join e apenas valores correspondentes da coleção a direita do join. Quaisquer itens da coleção do lado direito do join que não tenham um item correspondente na coleção do lado esquerdo do join são excluídos do resultado da consulta.

A cláusula Group Join executa, efetivamente, um LEFT OUTER JOIN. A diferença entre o que é tipicamente conhecido como LEFT OUTER JOIN e o que a cláusula Group Join retorna é que a cláusula Group Join agrupa os resultados da coleção do lado direito do join para cada item da coleção do lado esquerdo. Numa base de dados relacional, um LEFT OUTER JOIN retorna um resultado desagrupado no qual cada item na consulta contém itens correspondentes das coleções de ambos os lados do join. Neste caso, os itens da coleção do lado esquerdo do join são repetidos para cada item correspondente da coleção do lado direito. Você vai ver com que isso se parece quando você completar o próximo procedimento.

Você pode recuperar os resultados de uma consulta Group Join como um resultado desagrupado estendendo sua consulta para retornar um item para cada resultado agrupado de consulta. Para executar isso, você tem de garantir que você consulte o método DefaultIfEmpty da coleção agrupada. Isto assegura que itens da coleção do lado esquerdo do join ainda são incluídos no resultado da consulta mesmo se eles não têm resultados correspondentes na coleção do lado direito. 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.

To perform a Left Outer Join by using the Group Join clause

  • 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
    

Perform a Join by Using a Composite Key

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. The And keyword specifies that all specified key fields must match for items to be joined.

To perform a Join by using a composite key

  • 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
    

Run the Code

To add code to run the examples

  1. 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. Press F5 to run the examples.

Consulte também

Referência

Cláusula Join (Visual Basic)

Cláusula Join Group (Visual Basic)

Cláusula From (Visual Basic)

Cláusula Where (Visual Basic)

Conceitos

Introdução a LINQ no Visual Basic

Transformações de dados com LINQ (C#)

Outros recursos

LINQ no Visual Basic

Consultas (Visual Basic)