Utiliser le retour pour quitter une boucle?

Question

Si j'écris une boucle for, do ou while, est-il possible d'en sortir avec le mot-clé return?

Par exemple:

class BreakTest 
{ 
public static void Main() 
{ 
    for (int i = 1; i <= 100; i++) 
    { 
    if (i == 5) 
     **return;** 
    Console.WriteLine(i); 
    } 
    } 
} 

Je sais que le retour peut être utilisé pour sortir si les déclarations et je suis curieux de savoir ce que je ne l'ai jamais essayé (et ne peut pas accéder à mon logiciel pour écrire le code pour tester cette).

Answer 1

return quittera la méthode en cours (Main dans votre exemple). Utilisez break pour quitter la boucle.

Answer 2

pouvez faire cela. L'appel return; quittera Main(). Normalement, vous utiliseriez break; pour sortir de la boucle for à la place. Cela étant dit, il est souvent considéré comme une mauvaise pratique d'avoir plusieurs emplacements de retour au sein d'une seule et même fonction. Beaucoup de développeurs préfèrent avoir une seule déclaration de retour (si la méthode n'est pas déclarée avec void). Cela peut rendre le code plus facile à suivre, du point de vue de la compréhensibilité, et donc plus facile à maintenir et à tester.

Answer 3

Vous pouvez certainement faire ce que vous demandez. Il semble y avoir deux camps sur la question de savoir si vous devriez ou non. Il y en a qui disent qu'il ne devrait y avoir qu'un seul point de sortie d'une fonction. Ils suggèrent que vous devriez utiliser une variable d'indicateur pour enregistrer que vous devez quitter (et éventuellement toutes les données que vous devez retourner), puis retourner une fois que vous avez rompu votre boucle ou atteint la fin de vos arbres if/else .

Personnellement, je n'ai aucun problème avec plusieurs points de sortie d'une fonction, tant qu'ils sont symétriques. Qu'est-ce que je veux dire par "symétrique"? Eh bien, si je vais revenir de l'intérieur d'une boucle, alors je veux aussi revenir à la fin de la boucle (au cas où je n'atteindrais jamais la condition dans la boucle qui me ferait revenir plus tôt). Si je suis à l'intérieur d'un complexe, si/sinon la hiérarchie et moi revenons de l'un des cas, alors je devrais revenir de l'intérieur de chacun d'eux.

Voici quelques exemples rapides de la façon dont je préfère écrire mon code:

public string Search(IEnumerable<string> values) 
    { 
     foreach(string value in values) 
     { 
      if(SomeArbitraryCondition()) 
       return value; 
     } 

     return null; 
    } 

    public int PerformAction() 
    { 
     if (SomeArbitraryCondition()) 
     { 
      if (SomeArbitraryCondition()) 
      { 
       return 1; 
      } 
      else 
      { 
       return 2; 
      } 
     } 
     else 
     { 
      if (SomeArbitraryCondition()) 
      { 
       return 3; 
      } 
      else 
      { 
       return 4; 
      } 
     } 
    } 

Ce n'est pas vraiment une règle dure et rapide que je l'ai beaucoup réfléchi, mais il est tout simplement la façon que je préfère l'écrire parce que cela me semble le plus propre. Dans certains cas, il est plus logique d'utiliser une variable d'indicateur et de revenir simplement à un endroit.

public string Search(IEnumerable<string> values) 
    { 
     string found = null; 
     foreach(string value in values) 
     { 
      if(SomeArbitraryCondition()) 
       found = value; 
     } 

     return found; 
    } 

    public int PerformAction() 
    { 
     int state; 
     if (SomeArbitraryCondition()) 
     { 
      if (SomeArbitraryCondition()) 
      { 
       state = 1; 
      } 
      else 
      { 
       state = 2; 
      } 
     } 
     else 
     { 
      if (SomeArbitraryCondition()) 
      { 
       state = 3; 
      } 
      else 
      { 
       state = 4; 
      } 
     } 

     return state; 
    } 

Answer 4

chemin de réponse en souffrance mais return; Sortira votre méthode tout (donc hors de la boucle, aussi) si son type de retour est vide. Si ce n'est pas le cas, il ne sera compilé que si vous renvoyez le type de la méthode.

Answer 5

Gardez à l'esprit ces:

1. Vous pouvez le faire, mais pas recommandé car il automatiquement sorties de la méthode actuelle d'exécution.
2. Inutile lorsque d'autres instructions après la boucle sont obligatoires. importe les conditions (en raison de son comportement indiqué dans le 1er point ).
3. Peut créer un effet d'entraînement dans votre programme en essayant de résoudre une erreur/bug/faute donne lieu à de nombreux nouveaux. Cela rend le débogage un complexe bits .