使用 == 或 .Equals() 进行布尔比较

Question

我正在查看一些代码，发现如下所示：

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

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

据我所知，(IsEditable.Equals(false)) 与(IsEditable == false) 相同（也与(!IsEditable) 相同）。

除了个人喜好，.Equals() 和== 之间有什么区别，特别是用来比较bools？

Answer 1

这主要是一个可读性问题。我通常会使用==，因为这是我习惯看的。

特别是布尔值，你根本不需要比较它们

if(!IsEditable)

足够了

虽然，有时我自己会写if (val == false) 之类的东西，只是为了确保在我必须修改代码时不会误读它。

Answer 2

事实上，对于int、bool 等基本类型，调用Equals() 和== 是有区别的，因为CIL 有处理这些类型的指令。调用 Equals() 会强制对值进行装箱并进行虚方法调用，而使用 == 会导致使用单个 CIL 指令。

!value 和value == false 实际上是相同的，至少在与.NET 4.0 捆绑在一起的微软C# 编译器中。

因此，以下方法中的比较

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
}

将编译为以下 CIL 指令：

// 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

Answer 3

Equals 方式似乎要慢得多 - 在调试模式下大约慢 2.7 倍，在发布模式下超过 7 倍。

这是我快速而肮脏的基准：

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

运行它会产生以下结果：

处于调试模式

8959
2950
1874

在释放模式

5348
751
7

Equals 似乎是最慢的。 == 和 != 之间似乎没有什么区别。但是，if (!boolExpr) 显然是赢家。

Answer 4

如果你反编译 System.Boolean 并查看它，它的 Equals 重载是这样定义的：

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

我想 C# 编译器的优化器和 .Net JIT 编译器足够聪明，可以内联这些，至少对于发布/优化编译而言，使它们完全相同。

Answer 5

有一个区别 - 至少在 .NET 4.8 中 - 我相信原因是因为Oliver Hanappi's 回答中描述的拳击：

static void Main(string[] args)
{
     object lhs = true;
     object rhs = true;
 
     Console.WriteLine($"Are Equal - {(lhs == rhs ? "Yes" : "No")}"); // Outputs no
     Console.WriteLine($"Are Equal - {(lhs.Equals(rhs) ? "Yes" : "No")}"); // Outputs yes
     Console.ReadLine();
}

Answer 6

看看下面的引用Taken from here：

Equals 方法只是在 System.Object 中定义的一个虚拟方法，并且 被选择这样做的任何类覆盖。 == 运算符是 可以由类重载的运算符，但通常具有 身份行为。

对于 == 没有被重载的引用类型，它比较 两个引用是否引用同一个对象 - 这正是 Equals 的实现在 System.Object 中做了什么。

简而言之，Equals 实际上只是在做一个 == 反正。

Answer 7

在这种情况下，使用 bool 没有任何区别，但是使用其他内置的非引用类型则可以。

== 允许类型转换，如果它可以.Equals 不会

Answer 8

== 总是比.Equals 好。在整数比较的情况下，== 运行速度比.Equals 快​​。在下面的测试中，使用== 的经过时间为157，而.Equals 的经过时间为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);
    }
}