Чи може хтось пояснити цю дивну поведінку підписаними плавцями в 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помилково повертає істину, що призводить до бітового порівняння двох різних, але семантично однакових значень.

Коли принаймні одне поле не має 8 байтів, CanCompareBitsповертає помилкове значення, і код продовжує використовувати відображення для переходу до полів та виклику 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порівняння стилю:

У коментарі CanCompareBits йдеться про "Повернення правдиво, якщо тип валієтипу не містить вказівника і щільно упакований". І FastEqualsCheck використовує "memcmp", щоб пришвидшити порівняння.

Автор далі констатує проблему, описану ОП:

Уявіть, у вас є структура, яка містить лише поплавок. Що відбудеться, якщо одна містить +0,0, а друга містить -0,0? Вони повинні бути однаковими, але основні бінарні представлення різні. Якщо ви вкладете іншу структуру, яка перекриває метод рівних, оптимізація також буде невдалою.

Гіпотеза Вількса правильна. Що CanCompareBits робить, це перевірити, чи є відповідний тип значення "щільно упакованим" в пам'ять. Щільно упакована структура порівнюється шляхом простого порівняння двійкових бітів, що складають структуру; нещільно упакована структура порівнюється за допомогою виклику рівних для всіх членів.

Це пояснює спостереження SLaks про те, що він спростовує структури, які є парними; такі структури завжди щільно упаковані.

На жаль, як ми бачили тут, це вносить смислову різницю, оскільки побітове порівняння парних та рівних порівнянь парних дає різні результати.

Половина відповіді:

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)]) і не мають джерела.

Назад до здогадки, чому один випадок можна порівняти по бітах, а інший не може (проблеми з вирівнюванням можливо?)

Це справді відповідає мені, з gmcs Mono 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;
}

EDIT : Помилка також буває з плаваючими, але відбувається лише в тому випадку, якщо поля в структурі складають кратне 8 байт.

Він повинен бути пов'язаний з побітним порівнянням, оскільки 0.0має відрізнятися -0.0лише від бітового сигналу.

…що ти думаєш про це?

Завжди переосмислюйте значення рівності та значення GetHashCode. Це буде швидко і правильно.

Просто оновлення для цієї 10-річної помилки: вона була виправлена ( Застереження : я автор цього PR) в .NET Core, який, можливо, буде випущений у .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;
}

Це все ще помилково.

мені здається, що це помилково, якщо структура містить лише подвійні.

Він повинен бути пов'язаний з нулем, оскільки змінюється лінія

дд = -0,0

до:

дд = 0,0

результати в порівнянні є правдивими ...