C# Academy · Leçon

Méthodes itératrices avec yield return

Générez des séquences un élément à la fois.

Méthodes itératrices avec yield return est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Qu’est-ce qu’une méthode d’itération ?

Une méthode d’itération produit une séquence de valeurs une par une à l’aide de yield return. Le compilateur la transforme en machine à états, vous évitant ainsi de créer et de gérer vous-même une liste.

Votre première instruction yield return

Chaque yield return remet une valeur à l’appelant et suspend la méthode. L’exécution reprend juste après cette instruction lors de l’itération suivante.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> FirstThree()
    {
        yield return 1;
        yield return 2;
        yield return 3;
    }

    public static void Main()
    {
        foreach (var n in FirstThree())
            Console.WriteLine(n);
    }
}

yield return dans une boucle

La plupart des itérateurs utilisent yield dans une boucle. Ici, nous générons les premiers nombres pairs indiqués par count sans jamais allouer de collection.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Evens(int count)
    {
        for (int i = 0; i < count; i++)
            yield return i * 2;
    }

    public static void Main()
    {
        foreach (var n in Evens(5))
            Console.WriteLine(n);
    }
}

La méthode renvoie IEnumerable

Une méthode d’itération doit renvoyer IEnumerable<T> ou IEnumerator<T>, ou leurs versions non génériques. Vous n’écrivez jamais return avec une valeur ; vous utilisez uniquement yield return.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<string> Greetings()
    {
        yield return "hello";
        yield return "hi";
        yield return "hey";
    }

    public static void Main()
    {
        foreach (var g in Greetings())
            Console.WriteLine(g);
    }
}

L’exécution est suspendue puis reprise

L’état entre les instructions yield est automatiquement conservé. Les variables locales gardent leurs valeurs pendant les suspensions, ce qui facilite grandement la génération de totaux cumulés.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> RunningTotal(IEnumerable<int> nums)
    {
        int total = 0;
        foreach (var n in nums)
        {
            total += n;
            yield return total;
        }
    }

    public static void Main()
    {
        foreach (var t in RunningTotal(new[] { 1, 2, 3, 4 }))
            Console.WriteLine(t);
    }
}

Générer des séquences infinies

Comme les valeurs sont produites à la demande, un itérateur peut décrire sans risque une séquence infinie. C’est l’appelant qui décide quand arrêter de demander des valeurs.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Naturals()
    {
        int i = 1;
        while (true) yield return i++;
    }

    public static void Main()
    {
        int taken = 0;
        foreach (var n in Naturals())
        {
            Console.WriteLine(n);
            if (++taken == 5) break;
        }
    }
}

Transformer une séquence d’entrée

Les itérateurs excellent dans la création de chaînes de traitement : lire les éléments d’une séquence, les transformer, puis renvoyer les résultats de façon différée.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<string> Labelled(IEnumerable<int> nums)
    {
        foreach (var n in nums)
            yield return "item-" + n;
    }

    public static void Main()
    {
        foreach (var s in Labelled(new[] { 10, 20, 30 }))
            Console.WriteLine(s);
    }
}

Filtrer avec des itérateurs

Pour filtrer, renvoyez simplement les éléments que vous voulez conserver. Les éléments ignorés ne sont jamais produits, le code en aval ne les voit donc jamais.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> OnlyPositive(IEnumerable<int> nums)
    {
        foreach (var n in nums)
            if (n > 0) yield return n;
    }

    public static void Main()
    {
        foreach (var n in OnlyPositive(new[] { -2, 5, -1, 8 }))
            Console.WriteLine(n);
    }
}

Le compilateur construit une machine à états

En coulisses, le compilateur réécrit votre itérateur en une classe qui implémente IEnumerator<T>, en suivant un champ d’état masqué et une valeur Current. Vous bénéficiez gratuitement de tout ce mécanisme.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<char> Letters()
    {
        yield return 'a';
        yield return 'b';
        yield return 'c';
    }

    public static void Main()
    {
        IEnumerator<char> e = Letters().GetEnumerator();
        while (e.MoveNext())
            Console.WriteLine(e.Current);
    }
}

Composer plusieurs itérateurs

Les itérateurs s’enchaînent naturellement, car chacun renvoie un IEnumerable<T>. Transmettez la sortie d’un itérateur au suivant pour créer des chaînes de traitement lisibles.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Range(int start, int count)
    {
        for (int i = 0; i < count; i++) yield return start + i;
    }
    static IEnumerable<int> Squares(IEnumerable<int> nums)
    {
        foreach (var n in nums) yield return n * n;
    }

    public static void Main()
    {
        foreach (var n in Squares(Range(1, 4)))
            Console.WriteLine(n);
    }
}

Essayez par vous-même

Écrivez un itérateur qui regroupe une séquence d’entrée en blocs de taille fixe. Il renvoie des listes à la demande, ce qui montre toute la logique que peut contenir un seul itérateur bien conçu.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<List<int>> Batch(IEnumerable<int> source, int size)
    {
        var bucket = new List<int>();
        foreach (var n in source)
        {
            bucket.Add(n);
            if (bucket.Count == size) { yield return bucket; bucket = new List<int>(); }
        }
        if (bucket.Count > 0) yield return bucket;
    }

    public static void Main()
    {
        foreach (var group in Batch(new[] { 1, 2, 3, 4, 5 }, 2))
            Console.WriteLine(string.Join(",", group));
    }
}

Vérification rapide

Rappelez-vous le fonctionnement des méthodes d’itération.

Récapitulatif

Les méthodes d’itération utilisent yield return pour produire des séquences à la demande.

La méthode renvoie IEnumerable<T> ou IEnumerator<T>.
Chaque yield return émet une valeur et suspend l’exécution, tout en conservant l’état local.
Elles peuvent décrire sans risque des séquences infinies.
Le compilateur génère la machine à états pour vous.

Questions Fréquemment Posées

La leçon « Méthodes itératrices avec yield return » est-elle gratuite ?

Oui — le texte complet de « Méthodes itératrices avec yield return » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Méthodes itératrices avec yield return » ?

Générez des séquences un élément à la fois. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Méthodes itératrices avec yield return » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy