Sortir d'une boucle Foreach en C#

Pour arrêter une boucle C# foreach lorsqu’une condition est remplie, utilisez break. Cette instruction quitte la boucle englobante la plus proche, puis l’exécution reprend à la première instruction qui suit cette boucle. Utilisez return si la méthode qui contient la boucle doit également se terminer. Dans des boucles imbriquées, définissez un indicateur dans la boucle interne lorsque la condition est remplie, puis vérifiez-le après cette boucle pour interrompre la boucle externe.

Utiliser break pour quitter la boucle

Cet exemple recherche la valeur 4 dans une liste. La vérification a lieu avant l’affichage : la valeur correspondante et les suivantes ne sont donc pas traitées par la boucle. L’exemple affiche chaque valeur précédant 4, puis poursuit l’exécution après la boucle.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

        foreach (int number in numbers)
        {
            if (number == 4)
            {
                break;
            }

            Console.WriteLine(number);
        }

        Console.WriteLine("Loop finished");
    }
}

1
2
3
Loop finished

break quitte uniquement la boucle englobante la plus proche. L’exécution atteint ensuite Console.WriteLine("Loop finished"), qui se trouve après la boucle. Avec foreach, l’itération parcourt une séquence énumérable ; l’exemple utilise une List<int>. Placez la condition avant le traitement que vous souhaitez éviter pour l’élément correspondant. Si vous la placez après ce traitement, l’élément sera traité avant l’arrêt de la boucle.

return quitte la méthode qui le contient

Choisissez return lorsque la condition signifie que la méthode doit cesser tout le travail qu’il lui reste à effectuer. L’exemple affiche chaque valeur précédant 4, puis revient à Main.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        PrintBeforeFour(new List<int> { 1, 2, 3, 4, 5, 6 });
        Console.WriteLine("Back in Main");
    }

    static void PrintBeforeFour(List<int> numbers)
    {
        foreach (int number in numbers)
        {
            if (number == 4)
            {
                return;
            }

            Console.WriteLine(number);
        }

        Console.WriteLine("Method finished after the loop");
    }
}

1
2
3
Back in Main

Lorsque return est exécuté dans PrintBeforeFour, le contrôle revient à l’appelant et les instructions suivantes de cette méthode sont ignorées. Main reprend ensuite après l’appel. C’est différent de break, qui quitte la boucle tout en poursuivant l’exécution dans la même méthode. Pour une méthode qui renvoie une valeur, chaque chemin d’exécution doit également fournir une valeur du type de retour déclaré ; une méthode void peut utiliser un return sans valeur.

Utiliser un indicateur pour quitter des boucles imbriquées

Un break dans une boucle interne ne quitte que cette boucle. Si une correspondance trouvée à l’intérieur doit également arrêter une boucle foreach externe, définissez un indicateur dans la boucle interne au moment où la correspondance est trouvée, puis vérifiez cet indicateur après la boucle interne. L’exemple affiche les valeurs jusqu’à 4, puis arrête les deux boucles.

using System;

class Program
{
    static void Main()
    {
        int[][] rows =
        {
            new[] { 1, 2 },
            new[] { 3, 4 },
            new[] { 5, 6 }
        };
        bool found = false;

        foreach (int[] row in rows)
        {
            foreach (int value in row)
            {
                Console.WriteLine(value);
                if (value == 4)
                {
                    found = true;
                    break;
                }
            }

            if (found)
            {
                break;
            }
        }

        Console.WriteLine("Search finished");
    }
}

1
2
3
4
Search finished

Le break interne arrête le parcours de la ligne en cours. Après cette boucle, l’indicateur vaut toujours true, ce qui permet à la boucle externe de s’arrêter lors de sa vérification suivante. La valeur 4 est affichée parce que l’exemple affiche chaque valeur avant de la tester ; déplacez le test avant l’affichage si la valeur correspondante ne doit pas apparaître. Un indicateur est utile lorsque la décision est prise dans une logique imbriquée et que la boucle externe doit en tenir compte. Pour une condition vérifiée directement dans la boucle externe, un simple break est plus clair.

Choisir la bonne instruction de sortie

Utilisez break pour terminer la boucle en cours et poursuivre la méthode. Utilisez return pour terminer également la méthode qui contient la boucle. Utilisez un indicateur lorsqu’une boucle interne détermine que la boucle externe doit s’arrêter. Si vous devez seulement ignorer le reste de l’itération en cours et examiner l’élément suivant, utilisez continue : cette instruction ne termine pas la boucle. Ce sont des instructions de contrôle de flux C#, et non des appels de méthode. Choisissez l’instruction dont la portée correspond au travail que vous souhaitez arrêter, et placez la condition avant ou après le traitement selon que l’élément correspondant doit être traité.