Cómo: Combinar datos con LINQ usando cláusulas Join (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 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

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