Continuer dans les boucles imbriquées

Question

Dans cet exemple de code, existe-t-il un moyen de continuer sur la boucle externe à partir du bloc catch?

while 
{ 
    // outer loop 

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

Answer 1

MISE À JOUR: Cette question a été une source d'inspiration pour my article on this subject. Merci pour la bonne question! "Continuer" et "break" ne sont rien de plus qu'une syntaxe agréable pour un "goto". Apparemment, en leur donnant des noms mignons et en limitant leurs usages à des structures de contrôle particulières, ils ne sont plus attirés par la colère de la foule «tous les gotos sont tous mauvais tout le temps». Si vous voulez faire un continu à externe, vous pouvez simplement définir une étiquette en haut de la boucle externe et ensuite "goto" cette étiquette. Si vous pensiez que cela ne gênait pas la compréhension du code, alors cela pourrait être la solution la plus opportune.

Cependant, je considérerais ceci comme une opportunité de considérer si votre flux de contrôle bénéficierait d'un refactoring. Chaque fois que j'ai "break" conditionnel et "continuer" dans les boucles imbriquées, je considère refactoring.

Tenir compte:

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 refactorisation:

D'abord, extraire la boucle interne à une méthode:

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

En second lieu, peuvent toutes les boucles éliminés? Si vous faites une boucle parce que vous essayez de chercher quelque chose, refactornez-le en 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 
} 

S'il n'y a pas de boucle, il n'est pas nécessaire de rompre ou de continuer!

Answer 2

Swap la structure try/catch avec l'intérieur en boucle:

while { 
    try { 
    while { 
     throw; 
    } 
    } 
    catch { 
    continue; 
    } 
} 

Answer 3

n °
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; 
     } 
    } 
} 

Answer 4

Vous pouvez utiliser une coupure; déclaration.

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

Continue est utilisé pour revenir au début de la boucle en cours.

Si vous avez besoin de sortir plus de niveaux, vous devrez soit ajouter une sorte de 'si' ou utiliser le 'goto' redouté/non recommandé.

Answer 5

Utilisez break dans la boucle interne.

Answer 6

Vous voulez juste casser de l'intérieur qui continuerait l'extérieur.

while 
{ 
    // outer loop 

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

Answer 7

Je pense que la meilleure façon d'y parvenir serait d'utiliser la déclaration break. Pause termine la boucle actuelle et continue l'exécution à partir de laquelle il se termine. Dans ce cas, il faut terminer la boucle interne et revenir dans la boucle extérieure. Voici à quoi ressemblerait votre code:

while 
{ 
    // outer loop 

    while 
    { 
     // inner loop 
     try 
     { 
      throw; 
     } 
     catch 
     { 
      // break jumps to outer loop, ends inner loop immediately. 
      break; //THIS IS THE BREAK 
     } 
    } 
} 

Je crois que c'est ce que vous cherchiez à accomplir, n'est-ce pas? Merci!

Answer 8

Utilisez un propre type d'exception, par exemple MyException. Ensuite:

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

Cela fonctionnera pour continuer et rompre plusieurs niveaux d'instructions while imbriquées. Désolé pour la mauvaise mise en forme;)

Answer 9

while 
    { 
     // outer loop 

     while 
     { 
      // inner loop 
      try 
      { 
       throw; 
      } 
      catch 
      { 
       // how do I continue on the outer loop from here? 
       goto REPEAT; 
      } 
     } 
     // end of outer loop 
REPEAT: 
     // some statement or ; 
    } 

Problème résolu. (quoi? Pourquoi me donnez-vous ce regard sale?)

Answer 10

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; 
      } 
     } 
    } 

} 

}