Como: agrupar dados com o LINQ por meio de relações (Visual Basic)

Artigo
08/25/2010

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.

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.

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

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

Consulte também

Compartilhar via