Partilhar via

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

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 bases de dados relacionais reconhecerão a cláusula Join como um INNER JOIN e a cláusula Group Join como, efetivamente, um LEFT OUTER JOIN.

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

Criar um projeto e adicionar dados de exemplo

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

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

  2. Os exemplos neste tópico usam os tipos Person e os dados Pet 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

  1. 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 do join e apenas os valores correspondentes da coleção do lado direito do join. 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 cláusula Group Join retorna é que a cláusula Group Join agrupa os resultados da coleção do lado direito para cada item da coleção do lado esquerdo da junção. 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 encontrado na 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, deves garantir que consultas o método DefaultIfEmpty 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 de Group Join

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

Pode usar a palavra-chave And numa cláusula Join ou Group Join para identificar vários campos-chave a usar ao ligar valores das coleções que estão a ser 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

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

  1. Substitua o Sub Main no módulo do Module1 do seu projeto pelo código a seguir para executar os exemplos neste tópico.

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

    Console.ReadLine()
End Sub

  2. Pressione F5 para executar os exemplos.

Ver também

  • Last updated on