C# Academy · Leçon

yield break et arrêt anticipé

Arrêtez l’itération selon certaines conditions.

yield break et arrêt anticipé est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Arrêter un itérateur prématurément

Vous pouvez parfois vouloir qu’un itérateur cesse de produire des valeurs avant d’atteindre sa fin naturelle. L’instruction yield break termine immédiatement la séquence, comme un return pour les itérateurs.

Instruction yield break de base

yield break termine l’itérateur. Aucune autre valeur n’est produite et la boucle foreach qui le consomme se termine.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> UpToFive()
    {
        for (int i = 1; i <= 100; i++)
        {
            if (i > 5) yield break;
            yield return i;
        }
    }

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

Prendre les éléments tant qu’une condition est vraie

Un schéma courant consiste à renvoyer des éléments uniquement tant qu’une condition est vraie, puis à s’arrêter. yield break rend cette approche claire.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> WhileSmall(IEnumerable<int> nums)
    {
        foreach (var n in nums)
        {
            if (n >= 10) yield break;
            yield return n;
        }
    }

    public static void Main()
    {
        foreach (var n in WhileSmall(new[] { 2, 4, 8, 12, 3 }))
            Console.WriteLine(n);
    }
}

Clauses de garde avec yield break

Vous pouvez utiliser yield break au début d’un itérateur comme clause de garde. Si l’entrée est vide ou non valide, ne renvoyez aucun élément.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    static IEnumerable<string> Lines(string text)
    {
        if (string.IsNullOrEmpty(text)) yield break;
        foreach (var line in text.Split('\n'))
            yield return line;
    }

    public static void Main()
    {
        foreach (var l in Lines("a\nb\nc"))
            Console.WriteLine(l);
        Console.WriteLine("empty count: " + Lines("").Count());
    }
}

Limiter le nombre d’éléments renvoyés

Utilisez un compteur et yield break pour limiter le nombre d’éléments produits par un itérateur, même à partir d’une longue source.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Take(IEnumerable<int> source, int max)
    {
        int count = 0;
        foreach (var item in source)
        {
            if (count++ >= max) yield break;
            yield return item;
        }
    }

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

break côté appelant contre yield break

Une séquence peut se terminer de deux façons. L’appelant peut cesser de demander des valeurs avec break, ou l’itérateur peut cesser d’en produire avec yield break. Dans les deux cas, la boucle se termine, mais pour des raisons différentes.

using System;
using System.Collections.Generic;

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

    public static void Main()
    {
        // Caller decides to stop with break
        foreach (var n in Counting())
        {
            if (n > 3) break;
            Console.WriteLine(n);
        }
    }
}

yield break ne termine que l’itérateur courant

yield break quitte la méthode d’itération dans laquelle il apparaît, et non une éventuelle boucle externe de l’appelant. Le contrôle revient à celui qui énumérait la séquence.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Bounded(IEnumerable<int> nums, int limit)
    {
        foreach (var n in nums)
        {
            if (n > limit) yield break; // ends Bounded only
            yield return n;
        }
    }

    public static void Main()
    {
        var result = Bounded(new[] { 1, 2, 9, 3 }, 5);
        Console.WriteLine("iterator created, still running");
        foreach (var n in result) Console.WriteLine(n);
    }
}

Aucun yield return après yield break

Une fois que yield break est exécuté, l’itérateur est terminé. Tout code situé physiquement après cette instruction dans le même chemin est inaccessible pour la production de valeurs.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Demo(bool stopEarly)
    {
        yield return 1;
        if (stopEarly) yield break;
        yield return 2;
        yield return 3;
    }

    public static void Main()
    {
        Console.WriteLine("stopEarly = true:");
        foreach (var n in Demo(true)) Console.WriteLine(n);
        Console.WriteLine("stopEarly = false:");
        foreach (var n in Demo(false)) Console.WriteLine(n);
    }
}

Combiner filtrage et arrêt anticipé

Vous pouvez filtrer et terminer dans le même itérateur : ignorer certaines valeurs, en renvoyer d’autres, puis arrêter complètement lorsqu’une valeur sentinelle apparaît.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> UntilZero(IEnumerable<int> nums)
    {
        foreach (var n in nums)
        {
            if (n == 0) yield break;     // stop at sentinel
            if (n < 0) continue;         // skip negatives
            yield return n;
        }
    }

    public static void Main()
    {
        foreach (var n in UntilZero(new[] { 3, -1, 5, 0, 9 }))
            Console.WriteLine(n);
    }
}

Blocs yield break et finally

Si votre itérateur contient un bloc try/finally, le bloc finally s’exécute toujours lorsque yield break termine la séquence. Cela garantit le nettoyage, notamment la fermeture des ressources.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> WithCleanup()
    {
        try
        {
            yield return 1;
            yield break;
        }
        finally
        {
            Console.WriteLine("cleanup ran");
        }
    }

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

Essayez par vous-même

Combinez le filtrage et l’arrêt anticipé : produisez les nombres positifs, mais arrêtez-vous complètement dès que leur somme cumulée dépasse un budget.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> WithinBudget(IEnumerable<int> nums, int budget)
    {
        int spent = 0;
        foreach (var n in nums)
        {
            if (n <= 0) continue;
            if (spent + n > budget) yield break;
            spent += n;
            yield return n;
        }
    }

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

Vérification rapide

Rappelez-vous le rôle de yield break.

Récapitulatif

yield break termine prématurément un itérateur.

Il fonctionne comme un return sans valeur pour les itérateurs.
Utilisez-le pour la logique take-while, les gardes et les limites de décompte.
Il termine uniquement l’itérateur, pas la boucle appelante.
Les blocs finally s’exécutent toujours, ce qui garantit le nettoyage.

Questions Fréquemment Posées

La leçon « yield break et arrêt anticipé » est-elle gratuite ?

Oui — le texte complet de « yield break et arrêt anticipé » 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 « yield break et arrêt anticipé » ?

Arrêtez l’itération selon certaines conditions. 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 2 sur 4.

Combien de temps prend la leçon « yield break et arrêt anticipé » ?

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