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

Article
03/04/2013

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 leurs valeurs communes.Ces valeurs sont appelées valeurs de clés.Les développeurs familiarisés avec les concepts de base de données relationnelle reconnaîtront la clause Join comme une JOINTURE INTERNE et la clause Group Join comme, indéniablement, 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éation d'un projet et ajout d'exemples de données

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

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

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

Réalisation d'une jointure interne en utilisant la clause Join

Une JOINTURE INTERNE combine les données de deux collections.Les éléments pour lesquels les correspondances de valeurs de clés spécifiées sont incluses.Tous les éléments de l'une ou l'autre des collections qui n'ont pas d'élément correspondant dans l'autre collection sont exclus.

Dans 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 en utilisant la clause Join lorsque vous souhaitez utiliser des champs clés spécifiques dans la jointure.Dans ce cas, une clause Where peut encore être utilisée pour filtrer les résultats de la requête.

Pour effectuer une jointure interne en utilisant la clause Join

Ajoutez le code suivant au module Module1 dans 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

Réalisation d'une jointure externe gauche à l'aide de la clause Group Join

Une JOINTURE EXTERNE GAUCHE inclut tous les éléments de la collection située à gauche de la jointure et uniquement les valeurs correspondantes de la collection située à droite de la jointure.Tous les éléments de la collection située du côté droit de la jointure qui ne possèdent pas d'élément correspondant dans la collection de gauche sont exclus du résultat de la requête.

La clause Group Join effectue, en effet, une JOINTURE EXTERNE GAUCHE.La différence entre ce qui est habituellement appelé JOINTURE EXTERNE GAUCHE et ce que retourne la clause Group Join est que la clause Group Join regroupe des résultats de la collection située du côté droit de la jointure pour chaque élément de la collection de gauche.Dans une base de données relationnelle, une JOINTURE EXTERNE GAUCHE retourne un résultat dégroupé dans lequel chaque élément du résultat de la requête contient des éléments correspondants des deux collections de la jointure.Dans ce cas, les éléments de la collection située du côté gauche de la jointure sont répétés pour chaque élément correspondant de la collection située du côté droit.Vous verrez mieux de quoi il s'agit en complétant la procédure suivante.

Vous pouvez récupérer les résultats d'une requête Group Join sous la forme d'un résultat dégroupé en étendant votre requête afin de retourner un élément pour chaque résultat de requête groupé.Pour ce faire, vous devez vous assurer que vous interrogez la méthode DefaultIfEmpty de la collection groupée.Cela permet de garantir que les éléments de la collection située du côté 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 dans la collection située du côté droit.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 dans la collection située du côté droit de la jointure.

Pour effectuer une jointure externe gauche en utilisant la clause Group Join

Ajoutez le code suivant au module Module1 dans votre projet pour consulter des exemples de jointure externe gauche groupée et de jointure externe gauche dé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

Réalisation d'une jointure à l'aide d'une clé composite

Vous pouvez utiliser le mot clé And dans une clause Join ou Group Join pour identifier les différents champs clés à utiliser lors de l'établissement de correspondances entre les valeurs des collections qui sont jointes.Le mot clé And spécifie que tous les champs clés spécifiés doivent correspondre pour les éléments à joindre.

Pour effectuer une jointure en utilisant une clé composite

Ajoutez le code suivant au module Module1 de votre projet pour consulter des exemples d'une 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écution du code

Pour ajouter du code pour exécuter les exemples

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
```
Appuyez sur F5 pour exécuter les exemples.

Voir aussi

Partager via