Syntaxe LINQ : Method Syntax vs Query Syntax

1. Introduction

Dans le monde de LINQ, il y a deux grandes "écoles" pour écrire des requêtes, deux styles qui, au premier abord, peuvent sembler complètement différents. C’est Query Syntax (syntaxe de requête) et Method Syntax (syntaxe méthode). Et si tu as déjà pensé que la prog c’est que de la logique, aujourd’hui on va ajouter un peu d’art, parce que le choix du style, c’est souvent comme choisir entre un pinceau et un crayon : les deux dessinent, mais l’un est mieux pour la couleur, l’autre pour le contour.

Pourquoi deux syntaxes ? Bonne question ! Imagine que tu veux commander un café. Tu peux dire : "Je pourrais avoir un espresso avec du lait et une cuillère de sucre, s’il te plaît ?". Ou tu peux écrire sur un papier : "Espresso. Lait. 1 sucre". Les deux sont clairs, mais l’un est plus bavard, l’autre plus concis.

C’est pareil avec LINQ. Une syntaxe a été conçue pour ressembler au SQL des bases de données, l’autre pour être plus "C#-like" et flexible. Au final, le compilateur C# transforme les deux syntaxes en la même chose : des appels de méthodes. Donc le choix, c’est souvent une question de lisibilité et de préférence perso.

Allez, on regarde les deux.

2. Method Syntax

Ici, tu enchaînes les méthodes d’extension LINQ avec des points. Ce style est super populaire chez les devs .NET, parce que tu peux facilement ajouter des opérations, le résultat est toujours un IEnumerable<T>, et c’est pratique à écrire direct dans le code.

Exemple : Filtrer et trier des produits

var filteredProducts = products
    .Where(p => p.Price < 1000)          // On filtre par prix
    .OrderBy(p => p.Name)                // On trie par nom
    .ToList();                           // On convertit en List<Product>

Where, OrderBy et ToList — ce sont des méthodes d’extension LINQ, chacune retourne un nouveau set de données que tu peux encore manipuler.

Schéma

graph LR
A[products] --> B[Where]
B --> C[OrderBy]
C --> D[ToList]

Pourquoi Method Syntax c’est cool

• Ultra flexible : tu peux facilement faire des chaînes complexes avec plein d’opérations.
• Toutes les méthodes sont juste des méthodes C#, l’IDE t’aide avec l’autocomplétion.
• Tu peux tout faire (et même plus) que ce que propose LINQ.

Encore un exemple : sélectionner les noms de tous les utilisateurs de plus de 18 ans

Imaginons qu’on a une classe User :

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Maintenant, on prend les noms des utilisateurs majeurs :

List<User> users = ... // déclaré quelque part

var adultNames = users
    .Where(u => u.Age >= 18)
    .Select(u => u.Name)
    .ToList();

3. Query Syntax (style SQL)

Cette syntaxe a été inventée pour que les devs C# se sentent à la maison s’ils ont déjà fait du SQL. Ça ressemble à une requête de base de données et ça commence par le mot-clé from.

Exemple : même filtre et tri

var filteredProducts = 
    from p in products
    where p.Price < 1000
    orderby p.Name
    select p;

Ici, ça se lit comme une requête classique : "depuis la collection products, prends p, où p.Price < 1000, trie par p.Name, sélectionne p".

Schéma

flowchart TD
    A[products] -->|from p in products| B[where p.Price < 1000]
    B --> C[orderby p.Name]
    C --> D[select p]

Pourquoi Query Syntax c’est cool

• Ça ressemble au SQL, donc plus clair pour ceux qui ont déjà fait des bases de données.
• Plus lisible pour les longues requêtes avec plusieurs conditions, groupements, jointures (join).

Encore un exemple : sélectionner les noms des utilisateurs majeurs

var adultNames = 
    from u in users
    where u.Age >= 18
    select u.Name;

À noter : Ici, juste après select, tu peux choisir un champ précis — genre juste le nom.

4. Comparaison : Method Syntax vs Query Syntax

users.Where(...).Select(...)

from u in users where ... select ...

Sum

Count

IEnumerable<T>

IEnumerable<T>

.ToList()

Fun fact IRL

La plupart des exemples dans la doc officielle Microsoft sur LINQ sont donnés dans les deux styles. Mais dans le code pro, on voit de plus en plus le Method Syntax — c’est plus pratique pour intégrer avec les méthodes d’extension (Where, Select, OrderBy, etc).

Mélanger ou pas ? Quel style choisir

Tu peux mélanger les deux syntaxes dans un projet (même dans une requête — mais ça fait bizarre). Le principal, c’est d’éviter le code salade. En général, on choisit un style pour tout un module ou projet, pour que ce soit plus lisible.

Method Syntax est parfait pour les transformations en chaîne et pour utiliser tous les LINQ methods qui existent que sous forme de méthodes (Sum, Count, Any et d’autres).

Query Syntax est super pratique pour les tâches avec join, group by ou des conditions imbriquées — là, il gagne en lisibilité.

5. Conversion entre les styles : même chose, façon différente

LINQ dans C# transforme toute requête façon SQL (Query Syntax) en une chaîne d’appels de méthodes (Method Syntax). Donc, peu importe ce que tu écris, C# va tout ramener à des méthodes d’extension à la compilation.

Exemple 1 — filtrage :

Query Syntax :

var adults = from u in users
             where u.Age >= 18
             select u;

Method Syntax (équivalent) :

var adults = users.Where(u => u.Age >= 18);

Exemple 2 — sélection de champs (Select) :

Query Syntax :

var names = from u in users
            select u.Name;

Method Syntax :

var names = users.Select(u => u.Name);

7. Groupements et jointures (join, group by)

Créer de nouveaux objets

Ajoutons à notre appli d’apprentissage la possibilité d’afficher la liste des utilisateurs groupés par âge. Là, la différence de syntaxe saute aux yeux.

Query Syntax (groupement) :

var usersByAge = 
    from u in users
    group u by u.Age into ageGroup
    select new { Age = ageGroup.Key, Users = ageGroup.ToList() };

On groupe les utilisateurs par âge (group u by u.Age). Après into, on a la variable ageGroup — c’est le groupe lui-même.

Method Syntax (équivalent) :

var usersByAge = users
    .GroupBy(u => u.Age)
    .Select(ageGroup => new { Age = ageGroup.Key, Users = ageGroup.ToList() });

Encore plus costaud : jointure (join)

Imaginons qu’on a une liste de commandes (orders) et une liste d’utilisateurs (users). On veut obtenir les noms des utilisateurs et le montant de leurs commandes.

Query Syntax :

var userOrders =
    from user in users
    join order in orders on user.Id equals order.UserId
    select new { user.Name, order.Amount };

Method Syntax :

var userOrders = users.Join(
    orders,
    user => user.Id,
    order => order.UserId,
    (user, order) => new { user.Name, order.Amount }
);

8. Erreurs fréquentes, pièges et astuces

Une des confusions les plus courantes : si tu n’ajoutes pas .ToList(), le résultat n’est pas une liste, mais une "requête différée" (lazy query), qui ne s’exécutera qu’au premier parcours. C’est pratique, mais ça peut donner des surprises si la collection d’origine change après avoir écrit la requête. On parlera plus en détail de "l’exécution différée" plus tard (après avoir vu les méthodes LINQ).

Beaucoup de débutants se plantent en pensant qu’on peut utiliser toutes les méthodes LINQ en Query Syntax. Par exemple, tu ne peux pas juste écrire select sum(u.Age), il faut passer en Method Syntax (users.Sum(u => u.Age)).

2

Mission

C# SELF, niveau 31, leçon 1

Bloqué

Utilisation de la syntaxe de requête LINQ pour filtrer et trier

Utilisation de la syntaxe de requête LINQ pour filtrer et trier

Ouvrir