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

Artigo
04/07/2023

O Visual Basic fornece as Join cláusulas e Group Join consulta 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. Os desenvolvedores familiarizados com os conceitos de banco de dados relacional reconhecerão a Join cláusula como UMA JUNÇÃO INTERNA e a Group Join cláusula como, efetivamente, um LEFT OUTER JOIN.

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

Criar um projeto e adicionar dados de exemplo

Para criar um projeto que contém dados e tipos de exemplo

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.

Os exemplos neste tópico usam os Person tipos e Pet os dados 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 ingressadas em uma From cláusula e identifica os campos de chave correspondentes em uma Where cláusula. O Visual Basic ingressa 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

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 concluir 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 fazer isso, você precisa garantir que você consulte o DefaultIfEmpty método 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

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

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

Para executar uma junção usando uma chave composta

Adicione o código a Module1 seguir ao módulo 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

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

Sub Main()
    InnerJoinExample()
    LeftOuterJoinExample()
    CompositeKeyJoinExample()

    Console.ReadLine()
End Sub

Pressione F5 para executar o exemplo.

Compartilhar via