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 |
---|---|---|---|---|
Sélectionner |
Projettent des valeurs qui sont basées sur une fonction de transformation. |
select |
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 |
Exemples de syntaxe d'expression de requête
Sélectionner
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)