Break étiqueté en C# 15 : application pratique

Break et continue étiquetés en C# 15 : Quand et pourquoi utiliser les nouvelles étiquettes de boucles

C# 15 introduit la fonctionnalité tant attendue mais controversée — les break et continue étiquetés. Malgré les critiques d'une partie de la communauté, cette nouveauté résout des problèmes spécifiques qui surgissent lors du travail avec des boucles imbriquées et des expressions switch. Elle est particulièrement pertinente dans les cas où il faut interrompre non pas le bloc le plus interne, mais une boucle externe sans recourir à goto ni à des drapeaux.

Le problème de la sortie des structures imbriquées

Traditionnellement, C# ne permettait pas de spécifier explicitement quelle boucle interrompre avec les instructions break ou continue. Cela obligeait à introduire des drapeaux logiques supplémentaires, à découper le code en méthodes, ou à utiliser goto — ce qui va à l'encontre des principes de code propre. Par exemple, lors du traitement d'une structure de données bidimensionnelle, il est souvent nécessaire d'arrêter immédiatement toutes les itérations dès qu'une condition est remplie :

string foundValue = null;
bool shouldBreak = false;

for (int x = 0; x < xMax; x++)
{
    for (int y = 0; y < yMax; y++)
    {
        foundValue = GetValue(x, y);

        if (foundValue == targetValue)
        {
            shouldBreak = true;
            break;
        }
    }

    if (shouldBreak)
    {
        break;
    }
}

ProcessValue(foundValue);

Cette approche encombre non seulement le code, mais crée aussi un risque d'erreurs — par exemple, appeler ProcessValue même si la valeur n'a pas été trouvée. L'alternative consistant à extraire la logique dans une méthode séparée améliore la lisibilité, mais n'est pas toujours applicable, surtout si l'état de la boucle dépend de plusieurs variables externes.

Cas d'usage réels pour break/continue étiquetés

Le cas le plus convaincant pour utiliser des étiquettes est le travail avec switch à l'intérieur d'une boucle. Sans break étiqueté, il est impossible de sortir de la boucle externe depuis une branche case. Auparavant, les développeurs devaient recourir à goto ou encapsuler la logique dans des lambdas ou fonctions locales. Désormais, la solution est simple :

outer: foreach (var item in collection)
{
    switch (item.Type)
    {
        case ItemType.StopAll:
            break outer;
        case ItemType.SkipGroup:
            continue outer;
    }
}

Ce code exprime clairement l'intention : break outer termine toute la boucle, tandis que continue outer passe à l'itération suivante de la boucle externe. Cela est particulièrement utile dans les analyseurs syntaxiques, les machines à états finis et les systèmes de routage d'événements.

Quand éviter les étiquettes

Malgré leur correction technique, les break et continue étiquetés ne doivent pas être utilisés partout. Leur emploi est justifié uniquement dans les situations où les alternatives dégradent la lisibilité ou les performances. Dans la plupart des cas, préférez :

• Extraire la logique dans des méthodes séparées avec des retours anticipés (early return).
• Utiliser les opérateurs LINQ (FirstOrDefault, Any, etc.) pour trouver des valeurs.
• Utiliser des drapeaux uniquement avec des structures d'imbrication simples.

Les étiquettes sont justifiées lorsque :

• La boucle contient un switch avec de nombreux cases nécessitant un contrôle de flux au niveau de la boucle externe.
• Les performances sont critiques, et l'extraction en méthode est indésirable en raison du surcoût.
• La logique ne peut pas être décomposée sans perdre son intégrité sémantique.

Comparaison des approches : Étiquettes vs. Refactorisation

Examinons trois façons de mettre en œuvre le même scénario — la recherche d'une valeur dans une matrice avec possibilité de sauter des lignes et d'arrêter prématurément :

Approche 1 : Drapeaux

— Avantages : Compatible avec toutes les versions de C#.

— Inconvénients : Complexité cognitive élevée, risque d'erreurs.

Approche 2 : Découpage en méthodes

— Avantages : Lisibilité, testabilité, respect des principes SOLID.

— Inconvénients : Augmentation possible de la profondeur de la pile d'appels.

Approche 3 : Break/continue étiquetés

— Avantages : Compacité, expression précise de l'intention.

— Inconvénients : Applicabilité limitée, méconnaissance chez certains développeurs.

Le choix dépend du contexte. Pour la logique métier, préférez l'approche 2. Pour du code système ou des analyseurs — l'approche 3.

Points clés

• Les break et continue étiquetés en C# 15 résolvent un problème étroit mais réel : le contrôle de flux depuis des switch ou boucles imbriqués.
• N'utilisez pas les étiquettes au lieu de refactoriser : si la logique est complexe, mieux vaut l'extraire dans une méthode séparée.
• Cas d'usage classique — traitement d'une collection via foreach avec switch, où certains cases doivent terminer ou sauter des itérations de la boucle externe.
• La fonctionnalité est au statut Open, mais déjà acceptée dans le Working Set du groupe de langue C#.
• Évitez de comparer des exemples non équivalents : l'ancien et le nouveau code doivent résoudre la même tâche.

— Editorial Team