Compartir a través de

Cómo: Combinar datos con LINQ mediante combinaciones (Visual Basic)

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 bases de datos relacionales reconocerán la cláusula Join como INNER JOIN y la cláusula Group Join como LEFT OUTER JOIN.

Los ejemplos en este tema demuestran algunas maneras de combinar datos mediante las cláusulas de consulta Join y Group 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, abra Visual Studio y agregue un nuevo proyecto de aplicación de consola de Visual Basic. Haga doble clic en el archivo Module1.vb creado por Visual Basic.

  2. Los ejemplos de este tema emplean los tipos Person y Pet, así como los datos del siguiente ejemplo de código. Copie 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

Una inner JOIN combina datos de dos colecciones. Se incluyen los 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: una combinación implícita y una combinación explícita.

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

Puede especificar una combinación explícita mediante la Join cláusula cuando desee 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. Agregue el código siguiente al módulo Module1 de tu 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 comúnmente se conoce como LEFT OUTER JOIN y lo que la cláusula Group Join devuelve es que la cláusula Group Join agrupa los resultados de la colección del lado derecho del join para cada elemento de la colección del lado izquierdo. En una base de datos relacional, LEFT OUTER JOIN devuelve un resultado sin agrupar 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á el aspecto que tiene cuando complete el siguiente procedimiento.

Puede recuperar los resultados de una Group Join consulta como un resultado sin agrupar ampliando la consulta para devolver un elemento para cada resultado de consulta agrupado. Para ello, debe asegurarse de realizar una consulta en el método DefaultIfEmpty de la colección agrupada. Esto garantiza que los elementos de la colección del lado izquierdo de la combinación todavía se incluyan en el resultado de la consulta aunque no tengan 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. Agregue el siguiente código al módulo Module1 de su proyecto para ver ejemplos de una unión externa izquierda agrupada y una unión externa izquierda sin agrupar.

    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

Puede usar la And palabra clave en una Join cláusula o una Group Join cláusula para identificar múltiples campos clave que se usarán al emparejar valores de las colecciones unidas. 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. Agregue el código siguiente al módulo del Module1 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. Reemplace el Sub Main en el módulo Module1 de su proyecto por el código siguiente para ejecutar los ejemplos de este tema.

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

    Console.ReadLine()
End Sub

  2. Presione F5 para ejecutar los ejemplos.

Consulte también

  • Last updated on