Vue d'ensemble des opérateurs de requête standard
Les opérateurs de requête standard sont les méthodes qui composent le modèle LINQ (Language Integrated Query). La plupart de ces méthodes fonctionnent sur des séquences, une séquence étant un objet dont le type implémente l'interface IEnumerable ou l'interface IQueryable. Les opérateurs de requête standard fournissent des fonctions de requête, notamment le filtrage, la projection, l'agrégation, le tri, etc.
Il existe deux ensembles d'opérateurs de requête standard LINQ, l'un qui fonctionne sur les objets de type IEnumerable et l'autre sur les objets de type IQueryable. Les méthodes qui composent chaque ensemble sont des membres statiques des classes Enumerable et Queryable, respectivement. Elles sont définies comme des méthodes d'extension du type sur lequel elles fonctionnent. Cela signifie qu'elles peuvent être appelées à l'aide de la syntaxe de méthode statique ou de la syntaxe de la méthode d'instance.
De plus, plusieurs méthodes d'opérateur de requête standard fonctionnent sur des types autres que ceux basés sur IEnumerable ou IQueryable. Le type Enumerable définit deux méthodes de ce type qui fonctionnent toutes deux sur les objets de type IEnumerable. Ces méthodes, Cast``1(IEnumerable) et OfType``1(IEnumerable), vous permettent d'autoriser l'interrogation d'une collection non paramétrée, ou non générique, dans le modèle LINQ. Pour ce faire, elles créent une collection d'objets fortement typée. La classe Queryable définit deux méthodes similaires, Cast``1(IQueryable) et OfType``1(IQueryable), qui fonctionnent sur les objets de type Queryable.
Les opérateurs de requête standard diffèrent dans le déroulement de leur exécution, selon qu'ils retournent une valeur de singleton ou une séquence de valeurs. Les méthodes qui retournent une valeur de singleton (par exemple, Average et Sum) s'exécutent immédiatement. Les méthodes qui retournent une séquence diffèrent l'exécution de la requête et retournent un objet énumérable.
Dans le cas des méthodes qui fonctionnent sur des collections en mémoire, c'est-à-dire les méthodes qui étendent IEnumerable, l'objet énumérable retourné capture les arguments qui ont été passés à la méthode. Lorsque cet objet est énuméré, la logique de l'opérateur de requête est employée et les résultats de la requête sont retournés.
En revanche, les méthodes qui étendent IQueryable n'implémentent aucun comportement d'interrogation, mais génère une arborescence d'expression qui représente la requête à exécuter. Le traitement de requête est contrôlé par l'objet IQueryable source.
Les appels aux méthodes de requête peuvent être chaînés dans une requête unique, ce qui permet aux requêtes de devenir arbitrairement complexes.
L'exemple de code suivant montre comment les opérateurs de requête standard peuvent être utilisés pour obtenir des informations à propos d'une séquence.
Dim sentence = "the quick brown fox jumps over the lazy dog"
' Split the string into individual words to create a collection.
Dim words = sentence.Split(" "c)
Dim query = From word In words
Group word.ToUpper() By word.Length Into gr = Group
Order By Length _
Select Length, GroupedWords = gr
Dim output As New System.Text.StringBuilder
For Each obj In query
output.AppendLine(String.Format("Words of length {0}:", obj.Length))
For Each word As String In obj.GroupedWords
output.AppendLine(word)
Next
Next
'Display the output
MsgBox(output.ToString())
' This code example produces the following output:
'
' Words of length 3:
' THE
' FOX
' THE
' DOG
' Words of length 4:
' OVER
' LAZY
' Words of length 5:
' QUICK
' BROWN
' JUMPS
string sentence = "the quick brown fox jumps over the lazy dog";
// Split the string into individual words to create a collection.
string[] words = sentence.Split(' ');
// Using query expression syntax.
var query = from word in words
group word.ToUpper() by word.Length into gr
orderby gr.Key
select new { Length = gr.Key, Words = gr };
// Using method-based query syntax.
var query2 = words.
GroupBy(w => w.Length, w => w.ToUpper()).
Select(g => new { Length = g.Key, Words = g }).
OrderBy(o => o.Length);
foreach (var obj in query)
{
Console.WriteLine("Words of length {0}:", obj.Length);
foreach (string word in obj.Words)
Console.WriteLine(word);
}
// This code example produces the following output:
//
// Words of length 3:
// THE
// FOX
// THE
// DOG
// Words of length 4:
// OVER
// LAZY
// Words of length 5:
// QUICK
// BROWN
// JUMPS
Syntaxe d'expression de requête
Certains des opérateurs de requête standard les plus courants possèdent une syntaxe de mots clés du langage C# et Visual Basic dédiés qui leur permet d'être appelés dans le cadre d'une expression de requête. Pour plus d'informations sur les opérateurs de requête standard qui comportent des mots clés dédiés et sur leurs syntaxes correspondantes, consultez Syntaxe des expressions de requête pour les opérateurs de requête standard.
Extension des opérateurs de requête standard
Vous pouvez augmenter l'ensemble d'opérateurs de requête standard en créant des méthodes spécifiques au domaine appropriées pour votre domaine ou technologie cible. Vous pouvez également remplacer les opérateurs de requête standard par vos propres implémentations qui fournissent des services supplémentaires, tels que l'évaluation à distance, la traduction de requête et l'optimisation. Pour obtenir un exemple, consultez AsEnumerable``1.
Rubriques connexes
Les liens suivants renvoient aux rubriques contenant des informations supplémentaires sur les divers opérateurs de requête présentés selon leurs fonctionnalités.
Conversion des types de données
Voir aussi
Référence
Méthodes d'extension (Guide de programmation C#)
Concepts
Introduction aux requêtes LINQ (C#)
Syntaxe des expressions de requête pour les opérateurs de requête standard
Classification des opérateurs de requête standard en fonction de leur mode d'exécution