Sortir d'une boucle foreach à l'intérieur d'un bloc switch

Question

Comment sortir d'une boucle foreach à l'intérieur d'un bloc switch ?

Normalement, vous utilisez break mais si vous utilisez un break à l'intérieur d'un bloc switch, cela vous fera juste sortir d'un bloc switch et la boucle foreach continuera son exécution :

foreach (var v in myCollection)
{
    switch (v.id)
    {
        case 1:
            if (true)
            {
                break;
            }
            break;
        case 2;
            break
    }
}

Ce que je fais actuellement quand j'ai besoin de sortir de la foreach alors qu'au sein de la switch fixe un bool placée à l'extérieur de la boucle à true et en vérifiant la valeur de ce bool à chaque fois que la fonction foreach et avant d'entrer dans le bloc de commutation. Quelque chose comme ça :

bool exitLoop;
foreach (var v in myCollection)
{
    if (exitLoop) break;
    switch (v.id)
    {
        case 1:
            if (true)
            {
                exitLoop = true;
                break;
            }
            break;
        case 2;
            break
    }
}

Cela fonctionne mais je continue à penser qu'il doit y avoir une meilleure façon de faire que je ne connais pas...

EDIT : Je me demande pourquoi cela n'a pas été implémenté dans .NET de la manière très soignée dont cela fonctionne dans PHP comme mentionné par @jon_darkstar ?

$i = 0;
while (++$i) {
    switch ($i) {
    case 5:
        echo "At 5<br />\n";
        break 1;  /* Exit only the switch. */
    case 10:
        echo "At 10; quitting<br />\n";
        break 2;  /* Exit the switch and the while. */
    default:
        break;
    }
}

Answer 1

Votre solution est à peu près l'option la plus courante dans ce cas. Ceci étant dit, je mettrais votre contrôle de sortie à la fin :

bool exitLoop;
foreach (var v in myCollection)
{
    switch (v.id)
    {
        case 1:
            if (true)
            {
                exitLoop = true;
            }
            break;
        case 2;
            break
    }

    // This saves an iteration of the foreach...
    if (exitLoop) break;
}

L'autre option principale est de remanier votre code, et de retirer l'instruction switch et la boucle foreach dans une méthode distincte. Vous pourriez alors simplement return de l'intérieur de l'énoncé du commutateur.

Answer 2

Le booléen est un moyen. Une autre est l'utilisation d'étiquettes et de goto. Je sais que les gens considèrent le goto comme un péché capital, mais utilisé judicieusement (TRÈS judicieusement), il peut être utile. Dans ce cas, placez une étiquette juste après la fin de la boucle foreach. Lorsque vous voulez sortir de la boucle, il suffit d'aller à cette étiquette. Par exemple :

foreach(var v in myCollection) {
    switch(v.Id) {
        case 1:
            if(true) {
                goto end_foreach;
            }
            break;
        case 2:
            break;
    }
}
end_foreach:
// ... code after the loop

EDIT : certaines personnes ont mentionné le fait de sortir la boucle dans une méthode séparée afin de pouvoir utiliser return. Je vois l'avantage de cette solution car elle ne nécessite pas de goto et simplifie également la fonction originale qui contient la boucle. Cependant, si la boucle est simple et constitue l'objectif principal de la fonction qui la contient, ou si la boucle utilise des variables out ou ref, alors il est probablement préférable de la laisser en place et d'utiliser goto. En fait, comme le goto et l'étiquette se démarquent, cela rend probablement le code plus clair plutôt que plus lourd. Le mettre dans une fonction séparée pourrait rendre le code simple plus difficile à lire.

Answer 3

Vous pourriez extraire votre cycle foreach vers la méthode séparée et utiliser return déclaration. Ou vous pourriez faire comme ceci :

        foreach (object collectionElement in myCollection)
        {
            if (ProcessElementAndDetermineIfStop(collectionElement))
            {
                break;
            }
        }

        private bool ProcessElementAndDetermineIfStop(object collectionElement)
        {
            switch (v.id)
            {
                case 1:
                    return true; // break cycle.
                case 2;
                    return false; // do not break cycle.
            }
        }

Answer 4

Honnêtement ? C'est peut-être la seule situation où il est tout à fait valable et correct d'utiliser goto :

foreach (var v in myCollection) {
    switch (v.id) {
        case 1:
            if (true)
                // document why we're using goto
                goto finished;
            break;
        case 2;
            break
    }
}
finished: // document why I'm here

Answer 5

Il y a toujours la possibilité de restructurer votre code de façon à ce que vous puissiez return de la switch déclaration.