Como: agrupar dados com o LINQ por meio de relaçõ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 _firstName As String
     Public _lastName As String
   
     Public Property FirstName() As String
       Get
         Return _firstName
       End Get
       Set(ByVal value As String)
         _firstName = value
       End Set
     End Property
   
     Public Property LastName() As String
       Get
         Return _lastName
       End Get
       Set(ByVal value As String)
         _lastName = value
       End Set
     End Property
   End Class
   
   Class Pet
     Public _name As String
     Public _owner As Person
   
     Public Property Name() As String
       Get
         Return _name
       End Get
       Set(ByVal value As String)
         _name = value
       End Set
     End Property
   
     Public Property Owner() As Person
       Get
         Return _owner
       End Get
       Set(ByVal value As Person)
         _owner = value
       End Set
     End Property
   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.

No Visual Basic LINQ fornece duas opções para realizar uma junção interna: uma unir implícita e explícita uma unir.

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)
  
    ' "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)
    ' This code produces the following output:
    '
    ' Magnus:
    '     Daisy
    ' Terry:
    '     Barley
    '     Boots
    '     Blue Moon
    ' Charlotte:
    '     Whiskers
    ' Arlene:
  
  
    ' 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())
  End Sub
  
  ' This code produces the following output:
  '
  ' Magnus:       Daisy
  ' Terry:        Barley
  ' Terry:        Boots
  ' Terry:        Blue Moon
  ' Charlotte:    Whiskers
  ' Arlene:     
  

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)
  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

Conceitos

Introdução ao LINQ no Visual Basic

Referência

Cláusula de adição (Visual Basic)

Cláusula Join Group (Visual Basic)

A partir da cláusula (Visual Basic)

Clúasula Where (Visual Basic)

Outros recursos

LINQ no Visual Basic

Consultas(Visual Basic)