Partager via


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<T> ou l'interface IQueryable<T>. 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<T> et l'autre sur les objets de type IQueryable<T>. 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<T> ou IQueryable<T>. 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<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. Pour ce faire, elles créent une collection d'objets fortement typée. La classe Queryable définit deux méthodes similaires, Cast<TResult>(IQueryable) et OfType<TResult>(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<T>, 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<T> 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<T> 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<TSource>.

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.

Tri des données

Opérations ensemblistes

Filtrage des données

Opérations de quantificateur

Opérations de projection

Partitionnement des données

Opérations de jointure

Regroupement de données

Opérations de génération

Opérations d'égalité

Opérations d'élément

Conversion des types de données

Opérations de concaténation

Opérations d'agrégation

Voir aussi

Référence

Enumerable

Queryable

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

Méthodes d'extension (Visual Basic)