web-dev-qa-db-fra.com

Quand utiliser le mot clé 'continue' en C #

Récemment, je traversais un projet open-source et bien que je développe depuis plusieurs années sous .NET, je n’étais jamais tombé par hasard sur le mot clécontinueavant. 

Question: Quelles sont les meilleures pratiques ou domaines dans lesquels l'utilisation du mot clé continue serait bénéfique? Y a-t-il une raison pour laquelle je ne l'aurais peut-être pas vu auparavant?

c#.netcontinue
29
Rion Williams

Vous l'utilisez pour quitter immédiatement l'itération de la boucle en cours et commencer la prochaine, le cas échéant.

foreach (var obj in list)
{
    continue;

    var temp = ...; // this code will never execute
}

Un continue est normalement lié à une condition et cette condition peut généralement être utilisée à la place de continue; 

foreach (var obj in list)
{ 
    if (condition)
       continue;

    // code
}

Pourrait juste être écrit comme 

foreach (var obj in list)
{
    if (!condition)
    {
        // code
    }
}

continue devient plus attrayant si vous pouvez avoir plusieurs niveaux de logique if imbriquée dans la boucle. Une continue au lieu d'une imbrication pourrait rendre le code plus lisible. Bien entendu, le refactoring de la boucle et des conditions conditionnelles dans des méthodes appropriées rendrait également la boucle plus lisible.

42
Anthony Pegram

Le mot clé continue est utilisé pour ignorer le reste du bloc de boucle et continuer. Par exemple:

for(int i = 0; i < 5; i++)
{
   if(i == 3) continue; //Skip the rest of the block and continue the loop

   Console.WriteLine(i);
}

Imprimera:

0
1
2
4
15
Mike Christensen

Lorsque vous ne voulez pas break sortir de la boucle, mais que vous voulez la prochaine itération:

for (int i = 0; i < something; i++)
{
    if (condition)
        continue;

    // expensive calculations, skip due to continue
    // or due to the condition above I don't want to 
    // run the following code
    stuff();
    code();
}
11
Joe

Il empêche la nidification en profondeur.

foreach(var element in collection)
{
    doSomething();      
    doSomethingElse();
    if (condition1)
    {
        action1();
        action2();
        if (condition2)
        {
           action3();                            
        }
    }
}

pourrait être réécrit comme 

foreach(var element in collection)
{
    doSomething();      
    doSomethingElse();
    if (!condition1)
    {
       continue;
    }
    action1();
    action2();
    if (!condition2)
    {
       continue;
    }
    action3();
}

Si les blocs de code ne sont pas triviaux mais verticalement plus grands, l'utilisation de continue peut améliorer la lisibilité du code. Évidemment, il devrait être utilisé avec considération, comme toute autre construction de langage.

11
Konrad Morawski

Vous devriez l'utiliser avec parcimonie. 

Les meilleures boucles (= les plus faciles à lire) n'utilisent pas break ou continue, ce sont des sortes d'instructions goto structurées. 

Cela dit, 1 ou même 2 instructions break/continue ne rendront pas une boucle illisible, mais il est utile de clarifier leur utilisation et de la garder simple. 

7
Henk Holterman

continue et break sont en principe des déclarations meilleures (mais souvent simplement déguisées) goto ...

Chaque fois que vous êtes dans une boucle et que vous savez que tout ce qui va suivre doit être ignoré et poursuivi à la prochaine itération, vous pouvez utiliser continue... 

En tant que tels, ils doivent être utilisés rarement ... parfois ils rendent le code très lisible et clair (si l’alternative consisterait en plusieurs niveaux d’imbrication par exemple) ... la plupart du temps, ils ajoutent une confusion similaire à goto.

6
Yahia

Je suppose que la raison pour laquelle vous ne l’avez pas vue auparavant est que continue est en quelque sorte un cousin des goto, break et début returns des fonctions. Et nous savons tous que Goto est considéré comme dangereux , de nombreux développeurs ont donc tendance à l’éviter.

Pour moi, j’ai tendance à utiliser continue lorsque je veux nettoyer une boucle où il peut y avoir des valeurs dont je ne me soucie pas. En utilisant continue, je peux ignorer ces valeurs sans inclure la logique "importante" dans ma boucle dans une if imbriquée.

foreach (var v in GetSomeValues())
{
  if (ThisValueIsNotImportant(v)) continue;

  //Do important stuff with the value.
}
4
wageoghe

Ai-je manqué quelque chose en ne l'utilisant pas?

Cela semble être une question étrange à poser. Vraisemblablement, vous savez mieux que quiconque si vous avez besoin de commencer tôt la prochaine itération d'une boucle.

3
recursive

Considérez-le comme un "retour", mais uniquement applicable au contexte d'une boucle. Un exemple courant est une machine à états qui boucle toutes les entrées disponibles.

while(!SomeQueue.Empty)
{
    byte nextByte = SomeQueue.Dequeue();

    switch State:
    {
        case A:
            if(nextByte == Condition)
            {
                State = B;
            }
            else                
            {
                State = ParseError;
            }
            continue;
        case B:
            //Test nextByte
            State = C;
            continue;
        case C:
            //Test nextByte
            State = A;
            continue;
        case ParseError:
            //Do something for this condition
            State = A;
            continue;
}
3
whatsisname

Vous pouvez également utiliser l'instruction continue pour l'optimisation du code. quand vous êtes sûr que hors de toutes conditions, au moins une condition va se rencontrer. vous pouvez l'utiliser comme ci-dessous,

foreach (var element in List)
{
    if (condition1)
    {
        //do stuff .....
        continue;
    }
    if (condition2)
    {
        //do stuff ....
        continue;
    }
    .
    .
    .
    if (condition)
    {
        //do stuff ....
        continue;
    }
}

Ici, lorsque l'une des conditions de l'instruction If est remplie, toutes les instructions if restantes sont ignorées.

0
sdy