Continuer dans les boucles while imbriquées

Mise à JOUR: Cette question a été l'inspiration pour mon article sur ce sujet. Merci pour la grande question!

---

"continuer" et "pause" ne sont rien de plus qu'un agréable syntaxe pour un "goto". Apparemment, en leur donnant mignon noms et la restriction de leurs usages notamment les structures de contrôle, de ne plus attirer les foudres de la "toutes les gotos sont tous mauvais de tous les temps" de la foule.

Si ce que vous voulez faire est de continuer à l'extérieur, vous pourrait simplement définir une étiquette en haut de la boucle externe, puis "goto" de cette étiquette. Si vous estimé que cela n'a pas empêché la lisibilité du code, c'est peut-être le moyen le plus efficace de la solution.

Toutefois, je prendrais cela comme une occasion d'examiner si votre flux de contrôle gagnerait à refactoring. Chaque fois que j'ai conditionnelle "break" et "continue" dans les boucles imbriquées, je considère que le refactoring.

Considérer:

successfulCandidate = null;
foreach(var candidate in candidates)
{
  foreach(var criterion in criteria)
  {
    if (!candidate.Meets(criterion)) //Edited.
    {  //TODO: no point in continuing checking criteria.
       //TODO: Somehow "continue" outer loop to check next candidate
    }
  }
  successfulCandidate = candidate;
  break;
}
if (successfulCandidate != null) //do something

Deux techniques de refactoring:

Tout d'abord, l'extrait de la boucle interne à une méthode:

foreach(var candidate in candidates)
{
  if (MeetsCriteria(candidate, criteria))
  { 
      successfulCandidate = candidate;
      break;
  }
}

Seconde, peut tous les boucles à être éliminé? Si vous êtes en boucle parce que vous essayez de chercher quelque chose, puis à refactoriser dans une requête.

var results = from candidate in candidates 
              where criteria.All(criterion=>candidate.Meets(criterion))
              select candidate;
var successfulCandidate = results.FirstOrDefault();
if (successfulCandidate != null)
{
  do something with the candidate
}

Si il n'y a pas de boucles, puis il n'y a pas besoin de se casser ou continuent!

Vous pouvez utiliser une pause; la déclaration.

while
{
   while
   {
       try
       {
           throw;
       }
       catch 
       {
           break;
       }
   }
}

Continuer est utilisé pour sauter vers le haut de la boucle de courant.

Si vous avez besoin de sortir plus de niveaux que vous devrez ajouter une sorte de "si", ou de l'utilisation de la redoutable/pas recommandé 'goto'.

Pas.

Je suggère, l'extraction de la boucle interne dans une méthode distincte.

while
{
   //outer loop
       try
       {
           myMethodWithWhileLoopThatThrowsException()
       }
       catch 
       {
           //how do I continue on the outer loop from here?
           continue;
       }
   }
}

Vous veulent juste de se libérer de l'intérieur qui permettrait de continuer à l'extérieur.

while
{
   //outer loop

   while
   {
       //inner loop
       try
       {
           throw;
       }
       catch 
       {
           //how do I continue on the outer loop from here?
           break;
       }
   }
}

using System;

namespace Examples
{

    public class Continue : Exception { }
    public class Break : Exception { }

    public class NestedLoop
    {
        static public void ContinueOnParentLoopLevel()
        {
            while(true)
            try {
               //outer loop

               while(true)
               {
                   //inner loop

                   try
                   {
                       throw new Exception("Bali mu mamata");
                   }
                   catch (Exception)
                   {
                       //how do I continue on the outer loop from here?

                       throw new Continue();
                   }
               }
            } catch (Continue) {
                   continue;
            }
        } 
    }

}

}