Présentation des opérateurs de requête standard (C#)Standard Query Operators Overview (C#)

Les opérateurs de requête standard sont les méthodes qui forment le modèle de requête LINQ.The standard query operators are the methods that form the LINQ pattern. La plupart de ces méthodes fonctionnent sur des séquences, où une séquence est un objet dont le type implémente l’interface IEnumerable<T> ou l’interface IQueryable<T>.Most of these methods operate on sequences, where a sequence is an object whose type implements the IEnumerable<T> interface or the IQueryable<T> interface. Les opérateurs de requête standard fournissent des fonctionnalités de requête, dont notamment le filtrage, la projection, l’agrégation, le tri, etc.The standard query operators provide query capabilities including filtering, projection, aggregation, sorting and more.

Il existe deux ensembles d’opérateurs de requête standard LINQ, l’un opérant sur des objets de type IEnumerable<T> et l’autre sur des objets de type IQueryable<T>.There are two sets of LINQ standard query operators, one that operates on objects of type IEnumerable<T> and the other that operates on objects of type IQueryable<T>. Les méthodes qui composent chaque ensemble sont des membres statiques des classes Enumerable et Queryable, respectivement.The methods that make up each set are static members of the Enumerable and Queryable classes, respectively. Elles sont définies en tant que méthodes d’extension du type sur lequel elles opèrent.They are defined as extension methods of the type that they operate on. Cela signifie qu’elles peuvent être appelées à l’aide de la syntaxe de méthode statique ou de la syntaxe de méthode d’instance.This means that they can be called by using either static method syntax or instance method syntax.

De plus, plusieurs méthodes d’opérateur de requête standard fonctionnent sur des types autres que ceux basés sur IEnumerable<T> ou IQueryable<T>.In addition, several standard query operator methods operate on types other than those based on IEnumerable<T> or IQueryable<T>. Le type Enumerable définit deux de ces méthodes qui fonctionnent toutes deux sur les objets de type IEnumerable.The Enumerable type defines two such methods that both operate on objects of type IEnumerable. Ces méthodes, Cast<TResult>(IEnumerable) et OfType<TResult>(IEnumerable), vous permettent d’autoriser l’interrogation d’une collection non paramétrée, ou non générique, dans le modèle LINQ.These methods, Cast<TResult>(IEnumerable) and OfType<TResult>(IEnumerable), let you enable a non-parameterized, or non-generic, collection to be queried in the LINQ pattern. Pour cela, elles créent une collection fortement typée d’objets.They do this by creating a strongly-typed collection of objects. La classe Queryable définit deux méthodes similaires, Cast<TResult>(IQueryable) et OfType<TResult>(IQueryable), qui opèrent sur les objets de type Queryable.The Queryable class defines two similar methods, Cast<TResult>(IQueryable) and OfType<TResult>(IQueryable), that operate on objects of 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 singleton ou une séquence de valeurs.The standard query operators differ in the timing of their execution, depending on whether they return a singleton value or a sequence of values. Les méthodes qui retournent une valeur de singleton (par exemple, Average et Sum) s’exécutent immédiatement.Those methods that return a singleton value (for example, Average and Sum) execute immediately. Les méthodes qui retournent une séquence diffèrent l’exécution de la requête et retournent un objet énumérable.Methods that return a sequence defer the query execution and return an enumerable object.

Dans le cas des méthodes qui opèrent sur des collections en mémoire, c’est-à-dire des méthodes qui étendent IEnumerable<T>, l’objet énumérable retourné capture les arguments passés à la méthode.In the case of the methods that operate on in-memory collections, that is, those methods that extend IEnumerable<T>, the returned enumerable object captures the arguments that were passed to the method. Lorsque cet objet est énuméré, la logique de l’opérateur de requête est employée et les résultats de requête sont retournés.When that object is enumerated, the logic of the query operator is employed and the query results are returned.

En revanche, les méthodes qui étendent IQueryable<T> n’implémentent aucun comportement d’interrogation, mais créent une arborescence d’expressions qui représente la requête à exécuter.In contrast, methods that extend IQueryable<T> do not implement any querying behavior, but build an expression tree that represents the query to be performed. Le traitement des requêtes est géré par l’objet IQueryable<T> source.The query processing is handled by the source IQueryable<T> object.

Les appels aux méthodes de requête peuvent être chaînés dans une requête unique, ce qui permet de rendre les requêtes arbitrairement complexes.Calls to query methods can be chained together in one query, which enables queries to become arbitrarily complex.

L’exemple de code suivant illustre l’utilisation des opérateurs de requête standard pour obtenir des informations sur une séquence.The following code example demonstrates how the standard query operators can be used to obtain information about a sequence.

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êteQuery Expression Syntax

Certains des opérateurs de requête standard les plus courants ont une syntaxe de mots clés dédiée des langages C# et Visual Basic, qui permet de les appeler dans le cadre d’une expression de requête.Some of the more frequently used standard query operators have dedicated C# and Visual Basic language keyword syntax that enables them to be called as part of a query expression. Pour plus d’informations sur les opérateurs de requête standard qui ont 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 (C#).For more information about standard query operators that have dedicated keywords and their corresponding syntaxes, see Query Expression Syntax for Standard Query Operators (C#).

Extension des opérateurs de requête standardExtending the Standard Query Operators

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.You can augment the set of standard query operators by creating domain-specific methods that are appropriate for your target domain or technology. 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 des requêtes et l’optimisation.You can also replace the standard query operators with your own implementations that provide additional services such as remote evaluation, query translation, and optimization. Pour obtenir un exemple, consultez AsEnumerable.See AsEnumerable for an example.

Les liens suivants renvoient à des rubriques contenant des informations supplémentaires sur les divers opérateurs de requête standard, selon leurs fonctionnalités.The following links take you to topics that provide additional information about the various standard query operators based on functionality.

Tri des données (C#)Sorting Data (C#)

Opérations ensemblistes (C#)Set Operations (C#)

Filtrage des données (C#)Filtering Data (C#)

Opérations de quantificateur (C#)Quantifier Operations (C#)

Opérations de projection (C#)Projection Operations (C#)

Partitionnement des données (C#)Partitioning Data (C#)

Opérations de jointure (C#)Join Operations (C#)

Regroupement de données (C#)Grouping Data (C#)

Opérations de génération (C#)Generation Operations (C#)

Opérations d’égalité (C#)Equality Operations (C#)

Opérations d’élément (C#)Element Operations (C#)

Conversion des types de données (C#)Converting Data Types (C#)

Opérations de concaténation (C#)Concatenation Operations (C#)

Opérations d’agrégation (C#)Aggregation Operations (C#)

Voir aussiSee also