Les itérateurs vous permettent de produire une séquence de valeurs paresseusement, une à la fois, en utilisant le mot-clé yield — sans construire toute la collection en mémoire. Une méthode utilisant yield return devient un itérateur qui génère des valeurs à la demande, idéal pour les grandes séquences ou infinies et l'itération personnalisée.
// a method with `yield return` is an ITERATOR — produces values one at a time
public IEnumerable<int> GetNumbers(int n)
{
for (int i = 0; i < n; i++)
{
yield return i; // produce a value, PAUSE here, resume on the next request
}
}
foreach (var num in GetNumbers(1000000)) // generates lazily — minimal memory
{
Console.WriteLine(num);
if (num > 5) break; // only generated 7 values — the rest were never computed
}
yield return produit une valeur et met en pause la méthode, reprenant où elle s'est arrêtée à la prochaine itération (préservant l'état). Les valeurs sont générées à la demande — rien n'est calculé jusqu'à demande, et un break arrête la génération plus tôt.
// ❌ eager — builds the WHOLE list in memory first
public List<int> GetAll(int n)
{
var list = new List<int>();
for (int i = 0; i < n; i++) list.Add(i); // all n values in memory
return list;
}
// ✅ iterator — generates lazily, constant memory regardless of n
public IEnumerable<int> GetAll(int n)
{
for (int i = 0; i < n; i++) yield return i;
}
public IEnumerable<int> Fibonacci()
{
int a = 0, b = 1;
while (true) // infinite — but lazy, so it's fine
{
yield return a;
(a, b) = (b, a + b);
}
}
var first10 = Fibonacci().Take(10); // take only what you need
LINQ's deferred execution is built on iterators — Where/Select use yield internally
to process elements lazily, one at a time, as the result is enumerated.
Les itérateurs et le mot-clé yield sont des fonctionnalités C# importantes pour la génération de séquence paresseuse et efficace en mémoire, et les comprendre est utile pour traiter de grands ensembles de données et pour comprendre comment fonctionne LINQ.
L'avantage principal est de produire des séquences paresseusement, une valeur à la fois, à la demande — plutôt que de construire une collection entière en mémoire — ce qui est essentiel pour les grands ensembles de données (où matérialiser tout épuiserait la mémoire), les scénarios de streaming/traitement, et même les séquences infinies (comme générer les nombres de Fibonacci, impossible avec une liste mais trivial avec un itérateur paresseux, en ne prenant que ce dont vous avez besoin).
Le mécanisme yield return (produire une valeur, mettre en pause, reprendre avec l'état préservé) rend l'écriture de tels générateurs paresseux clean et naturelle.
Comprendre les itérateurs illumine aussi comment fonctionne l'exécution différée de LINQ — les opérateurs LINQ utilisent les itérateurs en interne pour traiter les éléments paresseusement à mesure que le résultat est énuméré, ce qui explique le comportement paresseux de LINQ.
Connaître les itérateurs (génération paresseuse avec yield, les avantages mémoire par rapport à la construction avide de collection, les séquences infinies, et la connexion à l'exécution différée de LINQ) est utile pour écrire du code de traitement de données efficace en mémoire et pour comprendre le modèle d'évaluation paresseuse de C# — les rendant utiles, connaissances pratiquement pertinentes pour un C# efficace et un sujet qui reflète la compréhension des capacités d'exécution différée du langage.
Bien que non nécessaire pour tous les scénarios, les itérateurs sont importants lors du traitement de grandes quantités de données efficacement ou lors de la construction de séquences paresseuses personnalisées, et les comprendre approfondit votre compréhension de LINQ et de l'évaluation paresseuse — les rendant utiles, connaissances pratiquement pertinentes pour un C# efficace et un sujet qui reflète la compréhension des capacités d'exécution différée du langage.