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

Artigo
02/21/2024

Visual Basic fornece as Join cláusulas de consulta e Group Join 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-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, uma JUNÇÃO EXTERNA ESQUERDA.

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

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 de Module1.vb criado pelo Visual Basic.

Os exemplos neste tópico usam os Person tipos e Pet 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. Os itens para os quais os valores de chave especificados correspondem são incluídos. Todos os itens de qualquer coleção que não tenham um item correspondente na outra coleção são excluídos.

No Visual Basic, o LINQ fornece duas opções para executar uma JUNÇÃO INTERNA: uma junção implícita e uma junção explícita.

Uma junção implícita especifica as coleções a serem unidas em uma From cláusula e identifica os campos-chave correspondentes em uma Where cláusula. Visual Basic une implicitamente as duas coleções com base nos campos de chave especificados.

Você pode especificar uma associação explícita usando a Join cláusula quando quiser ser específico sobre quais campos-chave usar na associaçã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 associação externa esquerda usando a cláusula de associação de grupo

A LEFT OUTER JOIN inclui todos os itens da coleção do lado esquerdo da junção e apenas os 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 tenham um item correspondente na coleção do lado esquerdo são excluídos do resultado da consulta.

A Group Join cláusula executa, com efeito, uma JUNÇÃO EXTERNA ESQUERDA. 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 da coleção do lado esquerdo. Em um banco de dados relacional, um LEFT OUTER JOIN retorna um resultado não agrupado 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 não agrupado estendendo sua consulta para retornar um item para cada resultado de consulta agrupada. Para fazer isso, você precisa garantir que você consulta o DefaultIfEmpty método da coleção agrupada. Isso garante que os itens da coleção do lado esquerdo da junção ainda sejam incluídos no resultado da consulta, mesmo que não tenham resultados correspondentes da coleção do lado direito. Você pode adicionar código à sua consulta para fornecer um valor de resultado padrão quando não houver nenhum valor correspondente da coleção do lado direito da associação.

Para executar uma Junção Externa Esquerda usando a cláusula Ingresso em 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 cláusula ou Group Join para identificar vários campos-chave a serem usados ao corresponder valores das coleções que estão sendo associadas. A And palavra-chave especifica que todos os campos-chave especificados devem corresponder para os itens a serem unidos.

Para executar uma junção usando uma chave composta

Adicione o seguinte código ao Module1 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 no módulo em seu projeto com o código a seguir para executar os exemplos neste tópico.

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

    Console.ReadLine()
End Sub

Pressione F5 para executar os exemplos.

Partilhar via