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

O Visual Basic fornece as cláusulas de consulta Join e Group Join para permitir que você combine o conteúdo de várias coleções com base em valores comuns entre as coleções. Esses valores são conhecidos como valores de chave . Desenvolvedores familiarizados com conceitos de banco de dados relacional reconhecerão a cláusula Join como INNER JOIN e a cláusula Group Join como, efetivamente, um LEFT OUTER JOIN.

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

Criar um projeto e adicionar dados de exemplo

Para criar um projeto que contenha dados e tipos de exemplo

1. Para executar os exemplos neste tópico, abra o Visual Studio e adicione um novo projeto de Aplicativo de Console do Visual Basic. Clique duas vezes no arquivo Module1.vb criado pelo Visual Basic.

2. Os exemplos neste tópico usam os tipos Person e os dados Pet do exemplo de código a seguir. Copie esse código para o 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
   

Executar uma junção interna usando a cláusula Join

Um INNER JOIN combina dados de duas coleções. Itens para os quais os valores de chave especificados correspondem estão incluídos. Todos os itens de qualquer coleção que não têm um item correspondente na outra coleção são excluídos.

No Visual Basic, o LINQ fornece duas opções para executar um INNER JOIN: uma junção implícita e uma junção explícita.

Uma junção implícita especifica as coleções a serem unidas em uma From cláusula e identifica os campos de chave correspondentes em uma Where cláusula. O Visual Basic une implicitamente as duas coleções com base nos campos de chave especificados.

Você pode especificar uma junção explícita usando a Join cláusula quando quiser ser específico sobre quais campos de chave usar na junção. Nesse caso, uma Where cláusula ainda pode ser usada para filtrar os resultados da consulta.

Para executar uma Junção Interna usando a cláusula Join

1. Adicione o código a seguir ao Module1 módulo em seu projeto para ver exemplos de uma junção interna implícita e explícita.

   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
   

Executar uma junção externa à esquerda usando a cláusula Junção de Grupo

Um LEFT OUTER JOIN inclui todos os itens da coleção do lado esquerdo da junção e apenas valores correspondentes da coleção do lado direito da junção. Todos os itens da coleção do lado direito da junção que não têm um item correspondente na coleção do lado esquerdo são excluídos do resultado da consulta.

A Group Join cláusula executa, na verdade, um LEFT OUTER JOIN. A diferença entre o que normalmente é conhecido como LEFT OUTER JOIN e o que a Group Join cláusula retorna é que os Group Join grupos de cláusulas resultam da coleção do lado direito da junção para cada item na coleção do lado esquerdo. Em um banco de dados relacional, um LEFT OUTER JOIN retorna um resultado desagrupado no qual cada item no resultado da consulta contém itens correspondentes de ambas as coleções na junção. Nesse caso, os itens da coleção do lado esquerdo da junção são repetidos para cada item correspondente da coleção do lado direito. Você verá como isso se parece quando finalizar o próximo procedimento.

Você pode recuperar os resultados de uma Group Join consulta como um resultado desagrupado estendendo sua consulta para retornar um item para cada resultado de consulta agrupada. Para isso, é preciso garantir que a consulta seja feita no método DefaultIfEmpty da coleção agrupada. Isso garante que os itens da coleção do lado esquerdo da junção ainda estejam incluídos no resultado da consulta, mesmo que não tenham resultados correspondentes da coleção do lado direito. Você pode adicionar código à consulta para fornecer um valor de resultado padrão quando não houver nenhum valor correspondente da coleção do lado direito da junção.

Para executar uma Junção Externa à Esquerda usando a cláusula Junção de Grupo

1. Adicione o seguinte código ao módulo Module1 em seu projeto para ver exemplos de uma junção externa esquerda agrupada e uma junção externa esquerda desagrupada.

   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
   

Executar uma junção usando uma chave composta

Você pode usar a And palavra-chave em uma Join ou Group Join cláusula para identificar vários campos de chave a serem usados ao corresponder valores das coleções que estão sendo ingressadas. A And palavra-chave especifica que todos os campos de chave especificados devem corresponder para que os itens sejam unidos.

Para executar uma junção usando uma chave composta

1. Adicione o seguinte código ao módulo Module1 em seu projeto para ver exemplos de uma junção que usa uma chave 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
   

Executar o código

Para adicionar código para executar os exemplos

1. Substitua o Sub Main no módulo Module1 em seu projeto pelo código a seguir para executar os exemplos neste tópico.

   Sub Main()
       InnerJoinExample()
       LeftOuterJoinExample()
       CompositeKeyJoinExample()
   
       Console.ReadLine()
   End Sub
   

2. Pressione F5 para executar os exemplos.

Consulte também

• LINQ
• Introdução ao LINQ no Visual Basic
• Cláusula de Junção
• Cláusula de Junção de Grupo
• Cláusula From
• Cláusula 'WHERE'
• Consultas
• Transformações de dados com LINQ (C#)