C# Language Pause


Exemple

Dans une boucle (for, foreach, do, while) l'instruction break interrompt l'exécution de la boucle la plus interne et retourne au code qui la suit. Il peut également être utilisé avec le yield dans lequel il spécifie qu'un itérateur a pris fin.

for (var i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break;
    }
    Console.WriteLine("This will appear only 5 times, as the break will stop the loop.");
}

Démo en direct sur .NET Fiddle

foreach (var stuff in stuffCollection)
{
    if (stuff.SomeStringProp == null)
        break;
    // If stuff.SomeStringProp for any "stuff" is null, the loop is aborted.
    Console.WriteLine(stuff.SomeStringProp);
}

L'instruction break est également utilisée dans les constructions à casse pour sortir d'un cas ou d'un segment par défaut.

switch(a)
{
    case 5:
        Console.WriteLine("a was 5!");
        break;

    default:
        Console.WriteLine("a was something else!");
        break;
}

Dans les instructions switch, le mot clé 'break' est requis à la fin de chaque instruction de cas. Ceci est contraire à certains langages qui permettent de passer à la prochaine déclaration de cas de la série. Des solutions de contournement pour cela incluraient des instructions «goto» ou empiler les instructions «case» de manière séquentielle.

Le code suivant donnera les numéros 0, 1, 2, ..., 9 et la dernière ligne ne sera pas exécutée. yield break signifie la fin de la fonction (pas simplement une boucle).

public static IEnumerable<int> GetNumbers()
{
    int i = 0;
    while (true) {
        if (i < 10) {
            yield return i++;
        } else {
            yield break;
        }
    }
    Console.WriteLine("This line will not be executed");
}

Démo en direct sur .NET Fiddle

Notez que contrairement à d'autres langages, il n'existe aucun moyen d'étiqueter une pause particulière en C #. Cela signifie que dans le cas de boucles imbriquées, seule la boucle la plus interne sera arrêtée:

foreach (var outerItem in outerList)
{
    foreach (var innerItem in innerList)
    {
        if (innerItem.ShoudBreakForWhateverReason)
            // This will only break out of the inner loop, the outer will continue:
            break; 
    }
}

Si vous souhaitez sortir de la boucle externe , vous pouvez utiliser l'une des stratégies suivantes:

  • Une déclaration de goto pour sortir de toute la structure en boucle.
  • Une variable d'indicateur spécifique ( shouldBreak dans l'exemple suivant) qui peut être vérifiée à la fin de chaque itération de la boucle externe.
  • Refactoring le code pour utiliser une instruction return dans le corps de la boucle la plus interne ou éviter toute la structure de la boucle imbriquée.
bool shouldBreak = false;
while(comeCondition)
{
    while(otherCondition)
    {
        if (conditionToBreak)
        {
            // Either tranfer control flow to the label below...
            goto endAllLooping;

            // OR use a flag, which can be checked in the outer loop:
            shouldBreak = true;
        }
    }

    if(shouldBreakNow)
    {
        break; // Break out of outer loop if flag was set to true
    }
}

endAllLooping: // label from where control flow will continue