Opérations de projection

La projection désigne l'opération de transformation d'un objet en une nouvelle forme qui se compose souvent uniquement des propriétés qui seront utilisées ensuite. À l'aide de la projection, vous pouvez créer un nouveau type qui est généré à partir de chaque objet. Vous pouvez projeter une propriété et exécuter une fonction mathématique sur celle-ci. Vous pouvez également projeter l'objet d'origine sans le modifier.

Les méthodes d'opérateur de requête standard qui effectuent la projection sont répertoriées dans la section suivante.

Méthodes

Nom de la méthode	Description	Syntaxe d'expression de requête C#	Syntaxe d'expression de requête Visual Basic	Informations supplémentaires
Select	Projettent des valeurs qui sont basées sur une fonction de transformation.	select	Select	Enumerable.Select Queryable.Select
SelectMany	Projettent des séquences de valeurs qui sont basées sur une fonction de transformation, puis les aplatit en une séquence unique.	Utiliser plusieurs clauses from	Utiliser plusieurs clauses From	Enumerable.SelectMany Queryable.SelectMany

Exemples de syntaxe d'expression de requête

Select

L'exemple suivant utilise la clause select en C# ou la clause Select en Visual Basic pour projeter la première lettre à partir de chaque chaîne d'une liste de chaînes.

        Dim words = New List(Of String) From {"an", "apple", "a", "day"}

        Dim query = From word In words 
                    Select word.Substring(0, 1)

        Dim sb As New System.Text.StringBuilder()
        For Each letter As String In query
            sb.AppendLine(letter)
        Next

        ' Display the output.
        MsgBox(sb.ToString())

        ' This code produces the following output:

        ' a
        ' a
        ' a
        ' d

            List<string> words = new List<string>() { "an", "apple", "a", "day" };

            var query = from word in words
                        select word.Substring(0, 1);

            foreach (string s in query)
                Console.WriteLine(s);

            /* This code produces the following output:

                a
                a
                a
                d
            */

SelectMany

L'exemple suivant utilise plusieurs clauses from en C# ou clauses From en Visual Basic pour projeter chaque mot à partir de chaque chaîne dans une liste de chaînes.

        Dim phrases = New List(Of String) From {"an apple a day", "the quick brown fox"}

        Dim query = From phrase In phrases 
                    From word In phrase.Split(" "c) 
                    Select word

        Dim sb As New System.Text.StringBuilder()
        For Each str As String In query
            sb.AppendLine(str)
        Next

        ' Display the output.
        MsgBox(sb.ToString())

        ' This code produces the following output:

        ' an
        ' apple
        ' a
        ' day
        ' the
        ' quick
        ' brown
        ' fox

            List<string> phrases = new List<string>() { "an apple a day", "the quick brown fox" };

            var query = from phrase in phrases
                        from word in phrase.Split(' ')
                        select word;

            foreach (string s in query)
                Console.WriteLine(s);

            /* This code produces the following output:

                an
                apple
                a
                day
                the
                quick
                brown
                fox
            */

Select et SelectMany

Le travail de Select() et SelectMany() est de produire une valeur de résultat (ou des valeurs) à partir de valeurs sources. Select() produit une valeur de résultat pour chaque valeur source. Le résultat total est donc une collection qui a le même nombre d'éléments que la collection source. Par opposition, SelectMany() produit un résultat total unique qui contient des sous-collections concaténées à partir de chaque valeur source. La fonction de transformation qui est passée en tant qu'argument à SelectMany() doit retourner une séquence énumérable de valeurs pour chaque valeur source. Ces séquences énumérables sont alors concaténées par SelectMany() pour créer une grande séquence.

Les deux illustrations suivantes montrent la différence conceptuelle entre les actions de ces deux méthodes. Dans chaque cas, supposons que la fonction de sélecteur (transformation) sélectionne le tableau de fleurs à partir de chaque valeur source.

Cette illustration représente la manière dont Select() retourne une collection qui a le même nombre d'éléments que la collection source.

Cette illustration représente la manière dont SelectMany() concatène la séquence intermédiaire de tableaux en une valeur de résultat final unique qui contient chaque valeur à partir de chaque tableau intermédiaire.

Exemple de code

Cet exemple suivant compare le comportement de Select() et SelectMany(). Le code crée un "bouquet" de fleurs en prenant les deux premiers éléments dans chaque liste de noms de fleur de la collection source. Dans cet exemple, la "valeur unique" qu'utilise la fonction de transformation Select<TSource, TResult>(IEnumerable<TSource>, Func<TSource, TResult>) est elle-même une collection de valeurs. Ceci nécessite que la boucle foreach (For Each enVisual Basic) supplémentaire énumère chaque chaîne dans chaque sous-séquence.

Class Bouquet
    Public Flowers As List(Of String)
End Class

Sub SelectVsSelectMany()
    Dim bouquets = New List(Of Bouquet) From { 
        New Bouquet With {.Flowers = New List(Of String)(New String() {"sunflower", "daisy", "daffodil", "larkspur"})}, 
        New Bouquet With {.Flowers = New List(Of String)(New String() {"tulip", "rose", "orchid"})}, 
        New Bouquet With {.Flowers = New List(Of String)(New String() {"gladiolis", "lily", "snapdragon", "aster", "protea"})}, 
        New Bouquet With {.Flowers = New List(Of String)(New String() {"larkspur", "lilac", "iris", "dahlia"})}}

    Dim output As New System.Text.StringBuilder

    ' Select()
    Dim query1 = bouquets.Select(Function(b) b.Flowers)

    output.AppendLine("Using Select():")
    For Each flowerList In query1
        For Each str As String In flowerList
            output.AppendLine(str)
        Next
    Next

    ' SelectMany()
    Dim query2 = bouquets.SelectMany(Function(b) b.Flowers)

    output.AppendLine(vbCrLf & "Using SelectMany():")
    For Each str As String In query2
        output.AppendLine(str)
    Next

    ' Display the output
    MsgBox(output.ToString())

    ' This code produces the following output:
    '
    ' Using Select():
    ' sunflower
    ' daisy
    ' daffodil
    ' larkspur
    ' tulip
    ' rose
    ' orchid
    ' gladiolis
    ' lily
    ' snapdragon
    ' aster
    ' protea
    ' larkspur
    ' lilac
    ' iris
    ' dahlia

    ' Using SelectMany()
    ' sunflower
    ' daisy
    ' daffodil
    ' larkspur
    ' tulip
    ' rose
    ' orchid
    ' gladiolis
    ' lily
    ' snapdragon
    ' aster
    ' protea
    ' larkspur
    ' lilac
    ' iris
    ' dahlia

End Sub

class Bouquet
{
    public List<string> Flowers { get; set; }
}

static void SelectVsSelectMany()
{
    List<Bouquet> bouquets = new List<Bouquet>() {
        new Bouquet { Flowers = new List<string> { "sunflower", "daisy", "daffodil", "larkspur" }},
        new Bouquet{ Flowers = new List<string> { "tulip", "rose", "orchid" }},
        new Bouquet{ Flowers = new List<string> { "gladiolis", "lily", "snapdragon", "aster", "protea" }},
        new Bouquet{ Flowers = new List<string> { "larkspur", "lilac", "iris", "dahlia" }}
    };

    // *********** Select ***********            
    IEnumerable<List<string>> query1 = bouquets.Select(bq => bq.Flowers);

    // ********* SelectMany *********
    IEnumerable<string> query2 = bouquets.SelectMany(bq => bq.Flowers);

    Console.WriteLine("Results by using Select():");
    // Note the extra foreach loop here.
    foreach (IEnumerable<String> collection in query1)
        foreach (string item in collection)
            Console.WriteLine(item);

    Console.WriteLine("\nResults by using SelectMany():");
    foreach (string item in query2)
        Console.WriteLine(item);

    /* This code produces the following output:

       Results by using Select():
        sunflower
        daisy
        daffodil
        larkspur
        tulip
        rose
        orchid
        gladiolis
        lily
        snapdragon
        aster
        protea
        larkspur
        lilac
        iris
        dahlia

       Results by using SelectMany():
        sunflower
        daisy
        daffodil
        larkspur
        tulip
        rose
        orchid
        gladiolis
        lily
        snapdragon
        aster
        protea
        larkspur
        lilac
        iris
        dahlia
    */

}

Voir aussi

Tâches

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

Comment : remplir des collections d'objets issues de plusieurs sources (LINQ)

Comment : retourner un résultat de requête LINQ en tant que type spécifique (Visual Basic)

Comment : fractionner un fichier en plusieurs fichiers à l'aide de groupes (LINQ)

Référence

select, clause (Référence C#)

Select, clause (Visual Basic)

System.Linq

Concepts

Vue d'ensemble des opérateurs de requête standard