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

• LINQ
• Introducción a LINQ en Visual Basic
• Cláusula Join
• Cláusula de Unión de Grupos
• Cláusula From
• Cláusula Where
• Consultas
• Transformaciones de datos con LINQ (C#)