Compartilhar via


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)