Кто-нибудь может объяснить это странное поведение с подписанными числами в 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.

Вот источник CanCompareBitsиз SSCLI:

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? Они должны быть одинаковыми, но базовое двоичное представление отличается. Если вы вложите другую структуру, которая переопределяет метод Equals, эта оптимизация также не будет выполнена.

Гипотеза Вилкса верна. То, что делает «CanCompareBits», проверяет, не является ли рассматриваемый тип значения «плотно упакованным» в памяти. Плотно упакованная структура сравнивается простым сравнением двоичных битов, составляющих структуру; слабо упакованная структура сравнивается путем вызова Equals для всех членов.

Это объясняет наблюдение SLaks, что оно воспроизводится со структурами, которые являются двойными; такие структуры всегда плотно упакованы.

К сожалению, как мы видели здесь, это вводит семантическое различие, потому что побитовое сравнение двойных чисел и сравнение равных двойных дает разные результаты.

Половина ответа:

Отражатель говорит нам, что 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)]) и не имеют доступного источника.

Вернемся к предположению, почему один случай можно сравнивать по битам, а другой - нет (возможно, проблемы с выравниванием?)

Это действительно так для меня, с Mono gmcs 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-летней ошибки: она была исправлена ( Отказ от ответственности : я автор этого 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

результаты сравнения являются правдой ...