Quelle est la boucle infinie C # correcte, pour (;;) ou while (true)? [fermé]

De retour dans mes jours C / C ++, coder une "boucle infinie" comme

while (true)

me semblait plus naturel et me semblait plus évident que

for (;;)

Une rencontre avec PC-lint à la fin des années 80 et des discussions sur les meilleures pratiques qui ont suivi m'ont brisé cette habitude. Depuis, j'ai codé les boucles en utilisant l' forinstruction de contrôle. Aujourd'hui, pour la première fois depuis longtemps, et peut-être mon premier besoin d'une boucle infinie en tant que développeur C #, je suis confronté à la même situation. L'un d'eux est-il correct et l'autre non?

while(true)
{

}

C'est toujours ce que j'ai utilisé et ce que j'ai vu d'autres utiliser pour une boucle qui doit être interrompue manuellement.

Le compilateur C # transformera les deux

for(;;)
{
    // ...
}

et

while (true)
{
    // ...
}

dans

{
    :label
    // ...
    goto label;
}

Le CIL pour les deux est le même. La plupart des gens trouvent que while(true)c'est plus facile à lire et à comprendre. for(;;)est plutôt cryptique.

La source:

J'ai un peu plus dérangé avec .NET Reflector , et j'ai compilé les deux boucles avec le "Optimize Code" dans Visual Studio.

Les deux boucles se compilent dans (avec .NET Reflector):

Label_0000:
    goto Label_0000;

Les rapaces devraient attaquer bientôt.

Je pense que cela peut être plus facile à lire et c'est certainement la norme à utiliser en C #:

while(true)
{
   //Do My Loop Stuff
}

Gasp, utilisez:

while (!false)
{

}

OU comme jsight l'a souligné, vous voudrez peut-être être doublement sûr:

while (!false && true)
{
}

Avant que les gens me crient dessus, c'est le même code CIL, j'ai vérifié :)

Pour ressasser quelques vieilles blagues:

1. N'utilisez pas " for (;;) {}" - cela fait pleurer la déclaration.
2. Sauf, bien sûr, vous " #define EVER ;;".

Si vous voulez aller à l'ancienne, goto est toujours pris en charge en C #:

STARTOVER:  
    //Do something
    goto STARTOVER;

Pour une boucle vraiment infinie, c'est la commande incontournable. =)

Je pense que while (true)c'est un peu plus lisible.

Dans les situations où j'avais besoin d'une véritable boucle infinie, j'ai toujours utilisé

while(true) {...}

Il semble mieux exprimer l'intention qu'une déclaration vide pour.

Personnellement, j'ai toujours préféré for(;;)précisément parce qu'il n'a pas de condition (par opposition à celle while (true)qui en a toujours une). Cependant, c'est vraiment un point de style très mineur, dont je ne pense pas qu'il vaut la peine de discuter de toute façon. Je n'ai pas encore vu de directive de style C # qui imposait ou interdisait l'une ou l'autre approche.

Personnellement, je préfère l' for (;;)idiome (venant d'un point de vue C / C ++). Bien que je convienne que le while (true)est plus lisible dans un sens (et c'est ce que j'ai utilisé à l'époque même en C / C ++), je me suis tourné vers l'utilisation de l' foridiome parce que:

• ça se démarque

Je pense que le fait qu'une boucle ne se termine pas (de manière normale) vaut la peine d'être `` appelé '', et je pense que cela le for (;;)fait un peu plus.

Le livre original K&R pour C, à partir duquel C # peut retracer son ascendance, recommandé

for (;;) ...

pour des boucles infinies. Il est sans ambiguïté, facile à lire et a une longue et noble histoire derrière lui.

Addendum (février 2017)

Bien sûr, si vous pensez que cette forme en boucle (ou toute autre forme) est trop cryptique, vous pouvez toujours simplement ajouter un commentaire .

// Infinite loop
for (;;)
    ...

Ou:

for (;;)    // Loop forever
    ...

Ce ne devrait while(true)pas être le cas while(1), c'est donc while(1)incorrect en C #, oui;)

Alternativement, on pourrait dire qu'avoir une boucle infinie est normalement une mauvaise pratique de toute façon, car elle nécessite une condition de sortie à moins que l'application ne fonctionne vraiment pour toujours. Cependant, s'il s'agit d'un missile de croisière, j'accepterai qu'une condition de sortie explicite ne soit pas nécessaire.

Bien que j'aime celui-ci:

for (float f = 16777216f; f < 16777217f; f++) { } 

Je préfère un code un peu plus «alphabétisé». Je suis beaucoup plus susceptible de faire quelque chose comme ça dans la pratique:

bool shouldContinue = true;
while (shouldContinue)
{
    // ...

    shouldContinue = CheckSomething();
}

Même moi, je dis aussi que celui ci-dessous est meilleur :)

while(true)
{

}

Si vous jouez au code-golf, je suggérerais for(;;). Au-delà, while(true)a le même sens et semble plus intuitif. Dans tous les cas, la plupart des codeurs comprendront probablement les deux variantes, donc cela n'a pas vraiment d'importance. Utilisez ce qui est le plus confortable.

En termes de lisibilité du code while(true)dans n'importe quelle langue, je pense que cela a plus de sens. En ce qui concerne la façon dont l'ordinateur le voit, il ne devrait vraiment pas y avoir de différence dans la société actuelle de compilateurs et d'interprètes très efficaces.

S'il y a une différence de performance à avoir, je suis sûr que la traduction vers MSIL sera optimisée. Vous pouvez vérifier cela si vous le souhaitez vraiment.

La seule raison que je dirais for(;;)est due aux limitations de CodeDom (alors que les boucles ne peuvent pas être déclarées à l'aide de CodeDom et que les boucles for sont considérées comme la forme la plus générale en tant que boucle d'itération).

C'est une raison assez vague de choisir ceci autre que le fait que l' forimplémentation de la boucle peut être utilisée à la fois pour le code normal et le code généré par CodeDom. Autrement dit, cela peut être plus standard.

En guise de note, vous pouvez utiliser des extraits de code pour créer une whileboucle, mais la boucle entière devrait être un extrait de code ...

Les deux ont la même fonction, mais les gens préfèrent généralement while(true). C'est facile à lire et à comprendre ...

Toute expression qui renvoie toujours vrai doit être OK pour la boucle while.

Exemple:

1==1 //Just an example for the text stated before 
true