En utilisant == ou .Equals () pour la comparaison booléenne

J'ai relu un peu de code, et j'ai trouvé quelque chose qui ressemblait à ceci:

public class MyClass
{
    public bool IsEditable { get; set; }

    public void HandleInput()
    {
        if (IsEditable.Equals(false))
        {
            //do stuff
        }
    }
}

Autant que je sache, (IsEditable.Equals(false)) est identique à (IsEditable == false) (et aussi le même que (!IsEditable)).

En plus de la préférence personnelle, quelle est la différence entre .Equals() et ==spécifiquement lorsqu'il est utilisé pour comparer bools?

source d'informationauteur Ryan Kohn

  1. 4

    La Equals voie semble être beaucoup plus lent - environ 2,7 fois en mode debug, et plus de sept fois en mode release.

    Voici ma rapide et sale de référence:

    public static void Main() {
bool a = bool.Parse("false");
bool b = bool.Parse("true");
bool c = bool.Parse("true");
var sw = new Stopwatch();
const int Max = 1000000000;
int count = 0;
sw.Start();
//The loop will increment count Max times; let's measure how long it takes
for (int i = 0; i != Max; i++) {
count++;
}
sw.Stop();
var baseTime = sw.ElapsedMilliseconds;
sw.Start();
count = 0;
for (int i = 0; i != Max; i++) {
if (a.Equals(c)) count++;
if (b.Equals(c)) count++;
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds - baseTime);
sw.Reset();
count = 0;
sw.Start();
for (int i = 0; i != Max; i++) {
if (a==c) count++;
if (b==c) count++;
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds - baseTime);
sw.Reset();
count = 0;
sw.Start();
for (int i = 0; i != Max; i++) {
if (!a) count++;
if (!b) count++;
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds - baseTime);
}

    L'exécution de ce produit les résultats suivants:

    En mode debug

    8959
2950
1874

    En mode release

    5348
751
7

    Equals semble être le plus lent. Il semble y avoir peu de différence entre == et !=. Cependant, if (!boolExpr) semble être le gagnant clair.

  2. 10

    C'est surtout un problème de lisibilité. Je serais normalement utiliser == parce que c'est ce que je suis habitué à regarder.

    Spécifiquement avec des booléens, vous n'avez pas à les comparer à tous les

    if(!IsEditable)

    suffira

    bien que, Parfois, je me dois d'écrire des choses comme if (val == false) juste pour être certain que je n'ai pas mal lu quand j'ai modifier le code.

  3. 7

    En fait, pour les types de base tels que intbool etc. il y a une différence entre un appel Equals() et == en raison du fait que le CIL a des instructions pour la manipulation de ces types. L'appel de Equals() forces de boxe de la valeur et de faire une méthode virtuelle d'appel, considérant que l'utilisation de == conduit à l'utilisation d'un seul CIL instruction.

    !value et value == false est en fait le même, au moins dans Microsoft du compilateur C# livré avec .NET 4.0.

    Par conséquent, les comparaisons à l'intérieur de l'méthodes suivantes

    public static int CompareWithBoxingAndVirtualMethodCall(bool value)
{
if (value.Equals(false)) { return 0; } else { return 1; }
}
public static int CompareWithCILInstruction(bool value)
{
if (value == false) { return 0; } else { return 1; }
if (!value) { return 0; } else { return 1; } //comparison same as line above
}

    de compiler à la suite de CIL instructions:

    //CompareWithBoxingAndVirtualMethodCall
ldarga.s 'value'
ldc.i4.0
call instance bool [mscorlib]System.Boolean::Equals(bool) //virtual method call
brfalse.s IL_000c //additional boolean comparison, jump for if statement
//CompareWithCILInstruction
ldarg.0
brtrue.s IL_0005 //actual single boolean comparison, jump for if statement
  4. 2

    Si vous décompiler Système.Boolean et la regarde, elle est Égale surcharges sont définies ainsi:

    public override bool Equals(object obj)
{
if (!(obj is bool))
return false;
else
return this == (bool) obj;
}
public bool Equals(bool obj)
{
return this == obj;
}

    J'aime à penser que le compilateur C# de l'optimiseur et de la .Net compilateur JIT serait assez intelligent pour inline, au moins pour libération/optimisé de compilations, de faire exactement la même.

  5. -1

    Prendre un coup d'oeil à la citation suivante Prises à partir d'ici:

    La méthode Equals est juste un monde virtuel défini dans le Système.Objet, et
    remplacée par celle des classes choisissez de le faire. L'opérateur == est un
    l'opérateur qui peut être surchargé par les classes, mais qui a d'habitude
    l'identité de comportement.

    Pour les types référence où == n'a pas été surchargé, il compare
    si deux références se rapportent au même objet - ce qui est exactement
    ce que la mise en œuvre d'égal à Égal dans le Système.Objet.

    Donc, en bref, Equals est vraiment juste faire une == de toute façon.

  6. -1

    Dans ce cas, avec des booléens, il ne fait aucune différence, mais avec d'autres intégrée non des types référence.

    == permet les conversions de types si l'on peut .Equals ne

  7. -1

    == est toujours mieux que .Equals. Dans le cas de la comparaison des entiers, == court plus vite que .Equals. Dans le test ci-dessous, le temps écoulé à l'aide de == 157, tandis que pour .Equals le temps écoulé est de 230.

    class Program
{        
static void Main(string[] args)
{
Program programObj = new Program();
programObj.mymethod();
programObj.mynextmethod();
}
void mynextmethod()
{
var watch = Stopwatch.StartNew();
for (int i = 0; i < 60000000; i++)
{
int j = 0;
if (i.Equals(j))
j = j + 1;
}
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
Console.WriteLine("Time take in method" + elapsedMs);
Console.ReadLine();
}
void mymethod()
{
var watch = Stopwatch.StartNew();
for (int i = 0; i < 60000000; i++)
{
int j = 0;
if (i == j)
j = j + 1;
}
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
Console.WriteLine("Time take in method" + elapsedMs);
}
}