谁能用C＃中的带符号浮点数解释这种奇怪的行为？

这是带有注释的示例：

class Program
{
    // first version of structure
    public struct D1
    {
        public double d;
        public int f;
    }

    // during some changes in code then we got D2 from D1
    // Field f type became double while it was int before
    public struct D2 
    {
        public double d;
        public double f;
    }

    static void Main(string[] args)
    {
        // Scenario with the first version
        D1 a = new D1();
        D1 b = new D1();
        a.f = b.f = 1;
        a.d = 0.0;
        b.d = -0.0;
        bool r1 = a.Equals(b); // gives true, all is ok

        // The same scenario with the new one
        D2 c = new D2();
        D2 d = new D2();
        c.f = d.f = 1;
        c.d = 0.0;
        d.d = -0.0;
        bool r2 = c.Equals(d); // false! this is not the expected result        
    }
}

所以，对于这个你有什么想法？

该错误在以下两行中System.ValueType：（我进入参考源）

if (CanCompareBits(this)) 
    return FastEqualsCheck(thisObj, obj);

（两种方法都是[MethodImpl(MethodImplOptions.InternalCall)]）

当所有字段均为8个字节宽时，CanCompareBits错误地返回true，从而导致两个不同但在语义上相同的值的按位比较。

当至少一个字段的宽度不为8个字节时，CanCompareBits返回false，代码继续使用反射在字段上循环并调用Equals每个值，正确地将其-0.0视为0.0。

这是CanCompareBitsSSCLI 的来源：

FCIMPL1(FC_BOOL_RET, ValueTypeHelper::CanCompareBits, Object* obj)
{
    WRAPPER_CONTRACT;
    STATIC_CONTRACT_SO_TOLERANT;

    _ASSERTE(obj != NULL);
    MethodTable* mt = obj->GetMethodTable();
    FC_RETURN_BOOL(!mt->ContainsPointers() && !mt->IsNotTightlyPacked());
}
FCIMPLEND

我在http://blogs.msdn.com/xiangfan/archive/2008/09/01/magic-behind-valuetype-equals.aspx找到了答案。

核心部分是上的源注释CanCompareBits，该注释ValueType.Equals用于确定是否使用memcmp-style比较：

CanCompareBits的注释说：“如果valuetype不包含指针并且紧密包装，则返回true”。而FastEqualsCheck使用“ memcmp”来加速比较。

作者继续陈述OP所描述的问题：

假设您有一个仅包含浮点数的结构。如果一个包含+0.0，另一个包含-0.0，将会发生什么？它们应该相同，但是基础二进制表示形式不同。如果嵌套其他覆盖Equals方法的结构，则优化也会失败。

维尔克斯的猜想是正确的。“ CanCompareBits”的作用是检查所查看的值类型是否在内存中“紧密包装”。通过简单地比较构成结构的二进制位，可以比较紧密打包的结构。通过在所有成员上调用Equals来比较松散的结构。

这就解释了SLaks的观察，即它的复制结构都是double的。这样的结构总是紧密地包装在一起。

不幸的是，正如我们在这里看到的那样，这引入了语义上的差异，因为双精度的按位比较和双精度的相等比较得出不同的结果。

半答案：

Reflector告诉我们这样ValueType.Equals()做是这样的：

if (CanCompareBits(this))
    return FastEqualsCheck(this, obj);
else
    // Use reflection to step through each member and call .Equals() on each one.

不幸的是CanCompareBits()和FastEquals()（两个静态方法）都是extern（[MethodImpl(MethodImplOptions.InternalCall)]），并且没有可用的源。

回到猜测为什么一种情况可以按位进行比较，而另一种情况则不能（可能是对齐问题？）

它不会给我真正的，具有单声道的的GMC 2.4.2.3。

更简单的测试用例：

Console.WriteLine("Good: " + new Good().Equals(new Good { d = -.0 }));
Console.WriteLine("Bad: " + new Bad().Equals(new Bad { d = -.0 }));

public struct Good {
    public double d;
    public int f;
}

public struct Bad {
    public double d;
}

编辑：该错误也发生在浮点数，但仅当结构中的字段加起来为8字节的倍数时才会发生。

它必须与逐位比较相关，因为0.0应该-0.0仅与信号位不同。

…你怎么看待这件事？

始终在值类型上覆盖Equals和GetHashCode。这将是快速而正确的。

只是对该10年错误的更新：它已在.NET Core中得到修复（免责声明：我是本PR的作者），该漏洞可能会在.NET Core 2.1.0中发布。

该博客文章解释了错误，我怎么固定它。

如果你这样做D2

public struct D2
{
    public double d;
    public double f;
    public string s;
}

这是真的。

如果你像这样

public struct D2
{
    public double d;
    public double f;
    public double u;
}

还是错的

我牛逼好像它是假的，如果结构仅持有双打。

它必须是零相关的，因为更改行

dd = -0.0

至：

dd = 0.0

结果比较是正确的...