CodeGym /Cours /C# SELF /Exécution différée

Exécution différée

C# SELF
Niveau 34, Leçon 0
Disponible

1. Intro

Imagine : t'as écrit une longue et belle requête LINQ et tu te dis — «Voilà, tout va être traité !» Mais ensuite tu remarques que rien ne se passe tant que tu ne comptes pas les éléments ou que tu ne transformes pas le résultat en tableau. Ce n'est pas un bug, c'est une feature.

Dans .NET, LINQ utilise l'exécution différée : la requête ne démarre pas tant que tu ne commences pas à vraiment extraire les données. C'est comme un serveur paresseux — il ne court pas en cuisine tant qu'il n'entend pas : «Apporte la bouffe !», même si la commande est déjà passée.

Ce comportement, qu'on appelle aussi calcul paresseux (Lazy Evaluation), rend LINQ super efficace quand tu bosses avec des sources de données énormes, potentiellement infinies ou gourmandes en ressources.

Exécution différée veut dire que la requête LINQ ne s'exécute pas dès que tu la définis. Elle commence à bosser seulement quand tu commences vraiment à parcourir ou regarder les données dans la collection.

Exemple illustratif


var numbers = new List<int> { 1, 2, 3, 4, 5 };

// Requête LINQ
var query = numbers.Where(n =>{
    Console.WriteLine($"On vérifie {n}");
    return n % 2 == 0;
});
Console.WriteLine("Requête définie, mais les nombres n'ont pas été vérifiés !");

// C'est seulement maintenant que ça commence !
foreach (var n in query)
{
    Console.WriteLine($"Trouvé pair : {n}");
}

Qu'est-ce qui va se passer ?
Quand tu lances ce code, tu verras qu'avant la boucle foreach rien ne s'affiche dans la console — même les conditions dans ton Where ne sont pas exécutées. Dès que tu commences à parcourir les éléments (genre avec foreach), la requête commence à tourner.

C'est ça la deferred execution — tant que tu ne demandes rien, personne ne fait rien !

2. Pourquoi on a besoin de l'exécution différée ?

L'exécution différée rend le code non seulement plus élégant, mais aussi super efficace. Pourquoi faire du boulot à l'avance si, au final, le résultat ne sert même pas ? C'est crucial quand tu bosses avec de grosses collections ou des flux de données qui arrivent petit à petit — imagine une source qui pourrait être infinie. Charger tout ça en mémoire d'un coup, c'est juste pas raisonnable.

En plus, l'exécution différée te permet de combiner et d'empiler les requêtes comme tu veux. Tu peux construire des chaînes LINQ complexes sans te soucier qu'elles s'exécutent tout de suite. Tout se passe seulement quand tu commences à récupérer les données — et pas une seconde avant.

Une analogie

L'exécution différée, c'est comme ta liste de courses sur ton téléphone : tu peux ajouter et modifier les articles autant que tu veux, mais tu vas au magasin seulement quand t'es vraiment prêt à acheter (et c'est là que tu utilises la liste).

3. Comment ça marche sous le capot ?

Les requêtes LINQ qui retournent un IEnumerable<T> sont généralement faites avec des itérateurs (yield return) ou des constructions paresseuses spéciales. À chaque fois que tu commences à parcourir la collection (genre avec foreach ou ToList()), la requête se lance à nouveau.

Point important

Si tu modifies la collection source entre la définition de la requête et son exécution, les nouvelles ou modifiées données seront aussi dans le résultat.

Exemple :


var numbers = new List<int> { 1, 2, 3 };
var query = numbers.Where(n => n > 1);
numbers.Add(4); // on ajoute un nouveau nombre
foreach (var n in query)
{
    Console.WriteLine(n); // affiche 2, 3, 4
}

Schéma : quand la requête LINQ s'exécute-t-elle ?


flowchart TD
    A[Définition de la requête LINQ] --> B{Exécution de la requête ?}
    B -- Non --> C[En attente]
    B -- Oui (genre foreach, ToList) --> D[Exécution de la requête]
    D --> E[Résultat ou action]
Schéma de la deferred execution : la requête "attend" jusqu'à l'utilisation réelle

4. Exemples où la "paresse" de LINQ compte

Filtrage paresseux


var bigNumbers = Enumerable.Range(1, 1_000_000_000)
    .Where(n => n % 123_456 == 0);

foreach (var n in bigNumbers.Take(5))
{
    Console.WriteLine(n);
}

Qu'est-ce qui se passe ici ?
La requête crée une collection potentiellement d'un milliard d'éléments, mais en vrai elle filtre et retourne seulement 5 nombres ! Tout le reste n'est même pas calculé et ne prend pas de mémoire.

Requêtes imbriquées et transactions

Imaginons qu'on a une liste de commandes et de produits, et qu'on veut récupérer les 5 premières commandes qui contiennent un produit précis.


var orders = GetBigOrderList(); // imaginons qu'il y a des milliers de commandes

var filtered = orders
    .Where(order => order.Products.Any(p => p.Name == "Café"))
    .Take(5);

foreach(var o in filtered)
{
    Console.WriteLine(o.Id);
}

LINQ ne regarde pas les autres commandes dès qu'il a trouvé 5 correspondances !

5. Les surprises

Des scénarios où l'exécution différée peut te surprendre :

Modification de la source après la définition de la requête

Comme on l'a vu plus haut, si tu modifies la collection source entre la définition et l'exécution réelle de la requête, la requête verra les nouvelles données.

Parcourir plusieurs fois la même requête

La requête LINQ s'exécute à chaque énumération.


var query = numbers.Where(n => {
    Console.WriteLine($"On vérifie {n}");
    return n % 2 == 0;
});

foreach(var n in query) {} // premier passage
foreach(var n in query) {} // deuxième passage — tout est recalculé

Si tu veux un résultat réutilisable — matérialise-le (fais un .ToList() ou .ToArray()).

6. Quand les requêtes LINQ NE sont PAS différées ?

Toutes les opérations LINQ ne sont pas différées. Certains méthodes font une exécution immédiate ("gourmande") (Immediate Execution). Par exemple :

  • .ToList()
  • .ToArray()
  • .Count()
  • .Average()
  • .Sum()
  • .First(), .Last(), .Single()

Elles forcent toutes LINQ à exécuter la requête tout de suite, parce qu'elles ne retournent pas un IEnumerable, mais un résultat direct.

Exemple :


var query = numbers.Where(n => n > 2);
var result = query.ToList(); // Ici la requête s'exécute direct !

7. Notion de "calcul paresseux" (Lazy Evaluation)

L'exécution différée (deferred execution) — c'est un exemple concret de calcul paresseux (Lazy Evaluation) en .NET.

Calcul paresseux — c'est quand le résultat n'est pas calculé tant qu'on n'en a pas vraiment besoin. En plus de LINQ, C# a d'autres mécanismes pour faire du lazy.

Classe Lazy<T>

C# propose un type spécial Lazy<T> pour créer des valeurs "à la demande".

Petit exemple :


// On crée un nombre paresseux, qui sera calculé seulement quand on le demande
var lazyValue = new Lazy<int>(() =>
{
    Console.WriteLine("Je calcule la valeur !");
    return 42;
});

Console.WriteLine("Objet Lazy créé, mais la valeur n'est pas calculée");
Console.WriteLine($"Valeur : {lazyValue.Value}"); // c'est là que le calcul se fait

Pourquoi faire ça ?
Par exemple, tu stockes un paramètre dont t'as rarement besoin, et son calcul est long ou coûteux en ressources.

8. Tableau : méthodes LINQ et mode d'exécution

Méthode Exécution différée Exécution immédiate
Where
✅ ❌
Select
✅ ❌
Take
✅ ❌
Skip
✅ ❌
Join
✅ ❌
ToList
❌ ✅
ToArray
❌ ✅
Count
❌ ✅
First
❌ ✅

9. Erreurs classiques et particularités d'implémentation

"Du boulot en trop" à cause des parcours répétés

Comme l'exécution différée relance les calculs à chaque parcours, parfois tu peux avoir des recalculs inutiles.


var expensiveQuery = bigList.Where(x => SomeHeavyCalculation(x));

var result1 = expensiveQuery.ToList(); // calculé — une fois
var result2 = expensiveQuery.ToList(); // calculé — deux fois (même résultat, mais on perd du temps)

Solution : matérialise les données une seule fois :
var cached = expensiveQuery.ToList();

"Attrape l'erreur si tu peux"

Si une fonction dans la requête lève une exception, elle apparaîtra seulement quand tu parcours la collection, pas quand tu définis la requête.

Modifier la collection pendant le parcours

Modifier une collection pendant qu'on la parcourt peut causer une exception InvalidOperationException.

2
Mission
C# SELF, niveau 34, leçon 0
Bloqué
Exécution différée et requêtes multiples
Exécution différée et requêtes multiples
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION