为什么 == 在 System.Double 中被覆盖而不在 System.Int32 中被覆盖，这会产生什么后果？

Question

在C#中为什么Double会覆盖==而Int32不会，效果如何？

我在看msdn库。

我看到这个关于 double 的链接并没有说太多 here （虽然我知道 double 是 Double 对象的简写）..它没有显示方法例如..

但是System.Double 上的这个链接确实提到了我正在寻找的东西here

它显示 Equality 运算符采用双精度，因此重载。

MSDN 中Double 的图像，然后在方法之后（在列出字段之前），它显示运算符，并显示相等运算符被覆盖

我可以点击“运算符”下的平等和it says

public static bool operator ==(
    double left,
    double right
)

而当我看到System.Int32 MSDN中Int32的图片如下

看那张图片，（System.Int32 的页面）看起来== 没有被覆盖。

为什么，这样做的后果是什么？

Answer 1

Int32 在 .NET 方面似乎非常特别。源代码中缺少的功能很可能已融入系统核心。

如果不在结构中声明这些运算符，则无法将结构/值类型与==、> 等进行比较。因为Int32 缺少这些，所以我得出了上面的结论。

做一个简单的测试并转储 IL，他们在做完全相同的比较，没有 CompareTo 或 Equals 被调用（我认为这确实发生了。我学到了一些东西！）。

public void TestInts()
{
    var x = 1;
    var y = 2;
    var equals = x == y;
}

.method public hidebysig 
    instance void TestInts () cil managed 
{
    // Method begins at RVA 0x2094
    // Code size 11 (0xb)
    .maxstack 2
    .locals init (
        [0] int32 x,
        [1] int32 y,
        [2] bool equals
    )

    IL_0000: nop
    IL_0001: ldc.i4.1
    IL_0002: stloc.0
    IL_0003: ldc.i4.2
    IL_0004: stloc.1
    IL_0005: ldloc.0
    IL_0006: ldloc.1
    IL_0007: ceq
    IL_0009: stloc.2
    IL_000a: ret
}

public void TestDoubles()
{
    var x = 1.7d;
    var y = 1.5d;
    var equals = x == y;
}
.method public hidebysig 
    instance void TestDoubles () cil managed 
{
    // Method begins at RVA 0x20ac
    // Code size 27 (0x1b)
    .maxstack 2
    .locals init (
        [0] float64 x,
        [1] float64 y,
        [2] bool equals
    )

    IL_0000: nop
    IL_0001: ldc.r8 1.7
    IL_000a: stloc.0
    IL_000b: ldc.r8 1.5
    IL_0014: stloc.1
    IL_0015: ldloc.0
    IL_0016: ldloc.1
    IL_0017: ceq
    IL_0019: stloc.2
    IL_001a: ret
}

上面的 IL 只是为这两种情况调用了标准 ceq opcode。根据 .NET 标准，Int32 应该在源代码中声明比较运算符，但它没有。

编辑：看起来好像所有整数值类型都是这样的。 Single、Double、Decimal 都有源代码中指定的运算符。 Int16、Int32、Int64、Byte，不要。

Answer 2

一个可能的原因是因为 Double.NaN。

对于== operator：MSDN 说：如果使用相等运算符（==）测试两个 Double.NaN 值是否相等，则结果为 false；两个 Double.NaN 值不被视为相等。如果通过调用 Equals 方法测试它们是否相等，则结果为真。当您想确定 Double 的值是否不是数字 (NaN) 时，另一种方法是调用 IsNaN 方法。

所以 == 运算符和 Double 的 Equals 方法对于 Double.NaN 有不同的行为，我认为这就是为什么 == 被 double 覆盖的原因。至于 int，则没有这种特殊情况。

演示差异的代码：

using System;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("NaN == NaN: {0}", Double.NaN == Double.NaN); 
      Console.WriteLine("NaN != NaN: {0}", Double.NaN != Double.NaN); 
      Console.WriteLine("NaN.Equals(NaN): {0}", Double.NaN.Equals(Double.NaN)); 
      Console.WriteLine("! NaN.Equals(NaN): {0}", ! Double.NaN.Equals(Double.NaN)); 
      Console.WriteLine("IsNaN: {0}", Double.IsNaN(Double.NaN));

      Console.WriteLine("\nNaN > NaN: {0}", Double.NaN > Double.NaN); 
      Console.WriteLine("NaN >= NaN: {0}", Double.NaN >= Double.NaN); 
      Console.WriteLine("NaN < NaN: {0}", Double.NaN < Double.NaN);
      Console.WriteLine("NaN < 100.0: {0}", Double.NaN < 100.0); 
      Console.WriteLine("NaN <= 100.0: {0}", Double.NaN <= 100.0); 
      Console.WriteLine("NaN >= 100.0: {0}", Double.NaN > 100.0);
      Console.WriteLine("NaN.CompareTo(NaN): {0}", Double.NaN.CompareTo(Double.NaN)); 
      Console.WriteLine("NaN.CompareTo(100.0): {0}", Double.NaN.CompareTo(100.0)); 
      Console.WriteLine("(100.0).CompareTo(Double.NaN): {0}", (100.0).CompareTo(Double.NaN)); 
   }
}
// The example displays the following output: 
//       NaN == NaN: False 
//       NaN != NaN: True 
//       NaN.Equals(NaN): True 
//       ! NaN.Equals(NaN): False 
//       IsNaN: True 
//        
//       NaN > NaN: False 
//       NaN >= NaN: False 
//       NaN < NaN: False 
//       NaN < 100.0: False 
//       NaN <= 100.0: False 
//       NaN >= 100.0: False 
//       NaN.CompareTo(NaN): 0 
//       NaN.CompareTo(100.0): -1 
//       (100.0).CompareTo(Double.NaN): 1

代码同样来自MSDN

Answer 3

使用 ILSpy 我可以看到 Double.Equals 有一些额外的逻辑来检查被比较的值是否为 NaN。

ILSpy 还将== 的主体反编译为：

public static bool operator ==(double left, double right)
{
    return left == right;
}

其他运算符遵循相同的模式，这很奇怪。可能是反编译错误？