Cómo: Combinar datos con LINQ usando cláusulas Join (Visual Basic)

  • Artículo

Visual Basic proporciona las Join cláusulas de consulta y Group Join para permitirle combinar el contenido de varias colecciones en función de los valores comunes entre las colecciones. Estos valores se conocen como valores de clave. Los desarrolladores familiarizados con los conceptos de base de datos relacionales reconocerán la Join cláusula como INNER JOIN y la Group Join cláusula como, de hecho, LEFT OUTER JOIN.

En los ejemplos de este tema se muestran algunas maneras de combinar datos mediante las cláusulas y Join queryGroup Join.

Crear un proyecto y agregar datos de ejemplo

Para crear un proyecto que contenga tipos y datos de ejemplo

  1. Para ejecutar los ejemplos de este tema, abre Visual Studio y agrega un nuevo proyecto de aplicación de consola de Visual Basic. Haz doble clic en el archivo Module1.vb creado por Visual Basic.

  2. En los ejemplos de este tema se usan los Person tipos y Pet los datos del ejemplo de código siguiente. Copia este código en el módulo predeterminado Module1 creado por 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

Realizar una combinación interna mediante la cláusula Join

Inner JOIN combina datos de dos colecciones. Elementos para los que coinciden los valores de clave especificados. Se excluyen los elementos de cualquiera de las colecciones que no tienen un elemento coincidente en la otra colección.

En Visual Basic, LINQ proporciona dos opciones para realizar una combinación INNER JOIN: una combinación implícita y una combinación explícita.

Una combinación implícita especifica las colecciones que se van a combinar en una From cláusula e identifica los campos clave coincidentes de una Where cláusula . Visual Basic combina implícitamente las dos colecciones en función de los campos clave especificados.

Puedes especificar una combinación explícita mediante la Join cláusula cuando desees ser específico sobre los campos clave que se van a usar en la combinación. En este caso, todavía se puede usar una Where cláusula para filtrar los resultados de la consulta.

Realizar una combinación interna mediante la cláusula Join

  1. Agrega el código siguiente al Module1 módulo del proyecto para ver ejemplos de una combinación interna implícita y 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

Realizar una combinación externa izquierda mediante la cláusula de combinación de grupo

LEFT OUTER JOIN incluye todos los elementos de la colección izquierda de la combinación y solo los valores coincidentes de la colección del lado derecho de la combinación. Los elementos de la colección del lado derecho de la combinación que no tienen un elemento coincidente en la colección del lado izquierdo se excluyen del resultado de la consulta.

La Group Join cláusula realiza, en efecto, una LEFT OUTER JOIN. La diferencia entre lo que se conoce normalmente como LEFT OUTER JOIN y lo que devuelve la Group Join cláusula es que la cláusula agrupa los Group Join resultados de la colección del lado derecho de la combinación para cada elemento de la colección del lado izquierdo. En una base de datos relacional, LEFT OUTER JOIN devuelve un resultado no agrupado en el que cada elemento del resultado de la consulta contiene elementos coincidentes de ambas colecciones de la combinación. En este caso, los elementos de la colección del lado izquierdo de la combinación se repiten para cada elemento coincidente de la colección del lado derecho. Verás el aspecto que tiene al completar el procedimiento siguiente.

Puedes recuperar los resultados de una Group Join consulta como resultado no agrupado si amplías la consulta para devolver un elemento para cada resultado de consulta agrupado. Para ello, debes asegurarte de consultar en el DefaultIfEmpty método de la colección agrupada. Esto garantiza que los elementos de la colección del lado izquierdo de la combinación se sigan incluyendo en el resultado de la consulta incluso si no tienen resultados coincidentes de la colección del lado derecho. Puedes agregar código a la consulta para proporcionar un valor de resultado predeterminado cuando no hay ningún valor coincidente de la colección del lado derecho de la combinación.

Realizar una combinación externa izquierda mediante la cláusula de combinación de grupo

  1. Agrega el código siguiente al Module1 módulo del proyecto para ver ejemplos de una combinación externa izquierda agrupada y una combinación externa izquierda desagrupada.

    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

Realizar una combinación mediante una clave compuesta

Puedes usar la And palabra clave en una Join cláusula o Group Join para identificar varios campos de clave que se van a usar al combinar valores de las colecciones. La And palabra clave especifica que todos los campos de clave especificados deben coincidir para que los elementos se unan.

Para realizar una combinación mediante una clave compuesta

  1. Agrega el código siguiente al Module1 módulo del proyecto para ver ejemplos de una combinación que usa una clave compuesta.

    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

ejecutar el código

Para agregar código para ejecutar los ejemplos

  1. Reemplaza en Sub Main el módulo del Module1 proyecto por el código siguiente para ejecutar los ejemplos de este tema.

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

    Console.ReadLine()
End Sub

  2. Presiona F5 para ejecutar el ejemplo.

Vea también