Comment : combiner des données avec LINQ à l'aide de jointures (Visual Basic)

Visual Basic fournit les clauses de requête Join et Group Join pour vous permettre de combiner le contenu de plusieurs collections en fonction de valeurs communes entre les collections. Ces valeurs sont appelées valeurs clé . Les développeurs familiarisés avec les concepts de base de données relationnelle reconnaîtront la clause Join comme INNER JOIN et la clause Group Join comme, en fait, une JOINTURE EXTERNE GAUCHE.

Les exemples de cette rubrique illustrent quelques façons de combiner des données à l’aide des clauses de requête Join et Group Join .

Créer un projet et ajouter des exemples de données

Pour créer un projet qui contient des exemples de données et de types

1. Pour exécuter les exemples de cette rubrique, ouvrez Visual Studio et ajoutez un nouveau projet d'application de console Visual Basic. Double-cliquez sur le fichier Module1.vb créé par Visual Basic.

2. Les exemples de cette rubrique utilisent les types et les données Person et Pet de l’exemple de code suivant. Copiez ce code dans le module par défaut Module1 créé par 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
   

Effectuer une jointure interne en utilisant la clause de jointure

Une JOINTURE INTERNE combine les données de deux collections. Les éléments pour lesquels les valeurs de clé spécifiées correspondent sont inclus. Tous les éléments d’une collection qui n’ont pas d’élément correspondant dans l’autre collection sont exclus.

En Visual Basic, LINQ fournit deux options pour effectuer une JOINTURE INTERNE : une jointure implicite et une jointure explicite.

Une jointure implicite spécifie les collections à joindre dans une clause From et identifie les champs clés correspondants dans une clause Where. Visual Basic joint implicitement les deux collections en fonction des champs clés spécifiés.

Vous pouvez spécifier une jointure explicite à l’aide de la clause Join lorsque vous souhaitez être précis sur les champs clés à utiliser dans la jointure. Dans ce cas, une clause Where peut toujours être utilisée pour filtrer les résultats de la requête.

Effectuer une jointure interne en utilisant la clause de jointure

1. Ajoutez le code suivant au module Module1 de votre projet pour voir des exemples de jointure interne implicite et explicite.

   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
   

Effectuer une jointure externe gauche à l’aide de la clause de jointure de groupe

Une JOINTURE EXTERNE GAUCHE inclut tous les éléments de la collection de gauche de la jointure et uniquement les valeurs correspondantes de la collection de droite de la jointure. Tous les éléments de la collection de droite de la jointure qui n’ont pas d’élément correspondant dans la collection de gauche sont exclus du résultat de la requête.

La clause Group Join exécute, en effet, une JOINTURE EXTERNE GAUCHE. La différence entre ce qui est généralement appelé JOINTURE EXTERNE GAUCHE et ce que la clause Group Join retourne est que les groupes de clauses Group Join proviennent de la collection de droite de la jointure pour chaque élément de la collection de gauche. Dans une base de données relationnelle, une JOINTURE EXTERNE GAUCHE renvoie un résultat non groupé dans lequel chaque élément du résultat de la requête contient des éléments correspondants des deux collections dans la jointure. Dans ce cas, les éléments de la collection de gauche de la jointure sont répétés pour chaque élément correspondant de la collection de droite. Vous verrez à quoi cela ressemble lorsque vous effectuerez la procédure suivante.

Vous pouvez récupérer les résultats d’une requête Group Join en tant que résultat non groupé en étendant votre requête pour renvoyer un élément pour chaque résultat de requête groupée. Pour ce faire, vous devez vous assurer que vous interrogez sur la méthode DefaultIfEmpty de la collection groupée. Cela garantit que les éléments de la collection de gauche de la jointure sont toujours inclus dans le résultat de la requête même s’ils n’ont pas de résultats correspondants de la collection de droite. Vous pouvez ajouter du code à votre requête pour fournir une valeur de résultat par défaut lorsqu’il n’existe aucune valeur correspondante de la collection de droite de la jointure.

Pour effectuer une jointure externe gauche à l'aide de la clause de jointure de groupe

1. Ajoutez le code suivant au module Module1 dans votre projet pour voir des exemples de jointure externe gauche groupée et d’une jointure externe gauche non groupée.

   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
   

Effectuer une jointure à l’aide d’une clé composite

Vous pouvez utiliser le mot clé And dans une clause Join ou Group Join pour identifier plusieurs champs clés à utiliser lors de la correspondance des valeurs des collections jointes. Le mot clé And spécifie que tous les champs de clé spécifiés doivent correspondre pour que les éléments soient joints.

Effectuer une jointure à l’aide d’une clé composite

1. Ajoutez le code suivant au module Module1 de votre projet pour voir des exemples de jointure qui utilise une clé composite.

   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
   

Exécuter le code

Pour ajouter du code pour exécuter les exemples

1. Remplacez le Sub Main dans le module Module1 de votre projet par le code suivant pour exécuter les exemples de cette rubrique.

   Sub Main()
       InnerJoinExample()
       LeftOuterJoinExample()
       CompositeKeyJoinExample()
   
       Console.ReadLine()
   End Sub
   

2. Appuyez sur F5 pour exécuter le projet.

Voir aussi

• LINQ
• Introduction à LINQ en Visual Basic
• Join (clause)
• Group Join (clause)
• From (clause)
• Where (clause)
• Requêtes
• Transformations de données avec LINQ (C#)