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

Artigo
02/25/2013

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

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

Share via