Vitesse d'expression booléenne (C#)

Question

Bonjour, je pensais à ce qui est mieux d'écrire (en matière de vitesse et/ou l'efficacité):

bool Method(...) { ... } 

... 

bool result = Method(...); 

if (result == false) 
{ ... } 
// or 

if (!result) 
{ ... } 

Ou encore ...

if (result == true) 
// or 

if (result) 

Je demande parce que j'utilise le premier (result == false) mais parfois il devient très long, surtout dans condition ? expr : expr déclarations.

Answer 1

Je ne pense pas qu'il y ait une différence, et s'il y en a, vous auriez probablement du mal à le mesurer. Toute différence est susceptible d'être dans le bruit de la mesure.

Answer 2

Personnellement, je recule chaque fois que je vois quelque chose comme result == false. À mon avis, c'est une mauvaise utilisation plutôt désagréable de l'opérateur de l'égalité et totalement inutile. Bien que j'imagine que le compilateur devrait transformer les deux expressions dans le même octet, vous voulez absolument utiliser !result. En effet, ce n'est pas seulement l'expression la plus directe et la plus logique, mais, comme vous l'avez mentionné, cela rend le code beaucoup plus court et plus lisible. Je pense que la grande majorité des codeurs C# seraient d'accord avec moi sur ce point.

Answer 3

La vitesse d'exécution est la même: les deux extraits sont compilés avec la même représentation de code MSIL.

L'utilisation de (result == false) au lieu de (!result) semble toutefois un peu bâclée.

Answer 4

Il n'y a pas de différence de performance dans le code d'exécution. La plupart des directives de codage dans les entreprises que j'ai travaillées préfèrent le résultat.

Answer 5

Vous devriez certainement utiliser l'expression avec le! opérateur, pas parce que c'est plus rapide mais parce que c'est plus sûr.

Si vous utilisez accidentellement un signe égal au lieu de deux, vous attribuez la valeur à la variable au lieu de comparer les valeurs:

if (result = false) { 

Pour d'autres types de données le compilateur peut attraper ce, comme une expression comme (id = 42) a une valeur entière donc il ne peut pas être utilisé dans l'instruction if, mais une expression comme (result = false) a une valeur booléenne donc le compilateur doit l'accepter.

(Un vieux truc de C est de mettre le premier littéral pour qu'il ne peut pas être une mission, mais qui est moins lisible que l'opérateur! Est une meilleure alternative.)

Answer 6

Bien que je suis d'accord avec @Noldorin que if(!result) est préférable, je trouve que if(result == false) et ses semblables sont très utiles si vous devez tester un booléen nullable, ce qui arrive le plus souvent dans les scénarios d'accès aux données.

Editer: Voici un exemple de programme qui explique les différentes façons d'utiliser l'opérateur d'égalité sur un booléen Nullable.

class Program 
{ 
    static void Main(string[] args) 
    { 
    TestNullBool(true); 
    TestNullBool(false); 
    TestNullBool(null); 
    Console.ReadKey(); 
    } 

    private static void TestNullBool(bool? result) 
    { 
    if (result == null) 
    { 
     Console.WriteLine("Result is null"); 
    } 
    if (result == false) 
    { 
     Console.WriteLine("Result is false"); 
    } 
    if (result == true) 
    { 
     Console.WriteLine("Result is true"); 
    } 
    } 
} 
/* Output: 
Result is true 
Result is false 
Result is null 
*/ 

Answer 7

Je pense qu'il y a trois étapes dans ce processus. D'abord, vous croyez qu'il devrait toujours y avoir une comparaison dans un if, donc vous écrivez if (this.isMonkey == true) banane.manger();

Ou, de façon plus réaliste

if(SpeciesSupervisor.getInstance().findsSimilarTo(Monkey.class, 2) == true) { 
    String f = new PropertyBundle("bananarepo").getField("banana store"); 
    EntitiyManager.find(Banana.class,f).getBananas().get(1).eat(); 
} 

Ensuite, vous apprenez qu'il est bien de se demander si (this.isMonkey) et que cette mise en forme permet une meilleure lecture comme une phrase dans cet exemple («si c'est un singe"). Mais enfin, vous vieillissez et vous apprenez que si (b) n'est pas très lisible, et que si (b == vrai) donne à votre pauvre cerveau une idée de ce qui se passe ici, et que toutes ces dures prétentions de "abus", "abus", yada yada, sont tous un peu exagéré.

Et quant à la performance. En Java, cela ne ferait pas la moindre différence. Je ne pense pas .NET est tellement pire. C'est l'optimisation la plus simple qu'un compilateur puisse faire, je parierais que l'argent est la même.

Cheers,

Niko