下面是带有注释的例子:

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

你觉得这个怎么样?


当前回答

这对我来说是真的,Mono的gmcs 2.4.2.3。

其他回答

它必须是零相关的,因为改变了直线

D.d = -0.0

to:

D.d = 0.0

结果比较是正确的…

简单的测试用例:

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

编辑:该错误也发生在float上,但仅在结构体中的字段加起来是8字节的倍数时才会发生。

维尔克斯的猜想是正确的。“CanCompareBits”所做的是检查所讨论的值类型是否在内存中“紧密地打包”。一个紧凑的结构是通过简单地比较组成结构的二进制位来比较的;松散包装的结构通过对所有成员调用Equals来进行比较。

这解释了SLaks的观察,即它用全是双精度的结构体进行还原;这样的结构总是紧凑的。

不幸的是,正如我们在这里看到的,这引入了语义上的差异,因为双精度对象的位比较和双精度对象的等号比较给出了不同的结果。

你觉得这个怎么样?

总是重写值类型上的Equals和GetHashCode。它将是快速和正确的。

一半答案:

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 ([methodimmpl (MethodImplOptions.InternalCall)]),并且没有可用的源。

回到猜测为什么一种情况可以通过比特进行比较,而另一种情况不能(可能是对齐问题?)