Czy ktoś może wyjaśnić to dziwne zachowanie za pomocą podpisanych pływaków w C #?

Oto przykład z komentarzami:

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

Więc, co o tym myślisz?

Błąd występuje w następujących dwóch wierszach System.ValueType: (wszedłem do źródła odniesienia)

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

(Obie metody są [MethodImpl(MethodImplOptions.InternalCall)])

Gdy wszystkie pola mają szerokość 8 bajtów, CanCompareBitsomyłkowo zwraca wartość true, co powoduje bitowe porównanie dwóch różnych, ale semantycznie identycznych wartości.

Gdy co najmniej jedno pole nie ma 8 bajtów szerokości, CanCompareBitszwraca wartość false, a kod kontynuuje użycie odbicia w celu zapętlenia pól i wywołania Equalskażdej wartości, co poprawnie traktuje -0.0jako równe 0.0.

Oto źródło 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

Odpowiedź znalazłem na stronie http://blogs.msdn.com/xiangfan/archive/2008/09/01/magic-behind-valuetype-equals.aspx .

Najważniejszy jest komentarz źródłowy CanCompareBits, który ValueType.Equalssłuży do określenia, czy użyć memcmpporównania w stylu:

Komentarz CanCompareBits mówi „Zwróć wartość true, jeśli typ wartości nie zawiera wskaźnika i jest ciasno upakowany”. A FastEqualsCheck używa „memcmp”, aby przyspieszyć porównanie.

Następnie autor dokładnie stwierdza problem opisany przez PO:

Wyobraź sobie, że masz strukturę, która zawiera tylko liczbę zmiennoprzecinkową. Co się stanie, jeśli jeden zawiera +0,0, a drugi zawiera -0,0? Powinny być takie same, ale podstawowa reprezentacja binarna jest inna. Jeśli zagnieżdżasz inną strukturę, która przesłania metodę Equals, optymalizacja również się nie powiedzie.

Przypuszczenie Vilxa jest prawidłowe. „CanCompareBits” sprawdza, czy dany typ wartości jest „ściśle upakowany” w pamięci. Ciasno upakowaną strukturę porównuje się po prostu przez porównanie bitów binarnych tworzących strukturę; luźno spakowaną strukturę porównuje się przez wywołanie równości dla wszystkich członków.

To wyjaśnia spostrzeżenie SLaksa, że ​​reprosuje strukturami, które są podwójne; takie struktury są zawsze szczelnie zapakowane.

Niestety, jak widzieliśmy tutaj, wprowadza to różnicę semantyczną, ponieważ porównanie bitowe podwójnych i równe porównanie podwójnych daje różne wyniki.

Połowa odpowiedzi:

Reflektor mówi nam, że ValueType.Equals()robi coś takiego:

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

Niestety obie CanCompareBits()i FastEquals()(obie metody statyczne) są extern ( [MethodImpl(MethodImplOptions.InternalCall)]) i nie mają dostępnego źródła.

Wróć do zgadywania, dlaczego jeden przypadek może być porównywany bitami, a drugi nie. (Może problemy z wyrównaniem?)

To ma dać prawdziwe dla mnie, z GMC Mono 2.4.2.3.

Prostszy przypadek testowy:

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

EDYCJA : Błąd występuje również w przypadku liczb zmiennoprzecinkowych, ale występuje tylko wtedy, gdy pola w strukturze sumują się do wielokrotności 8 bajtów.

Musi być związany z porównaniem bit po bicie, ponieważ 0.0powinien różnić się -0.0tylko bitem sygnału.

…co o tym myślisz?

Zawsze zastępuj Equals i GetHashCode dla typów wartości. Będzie szybko i poprawnie.

Tylko aktualizacja tego 10-letniego błędu: została naprawiona ( Disclaimer : Jestem autorem tego PR) w .NET Core, który prawdopodobnie zostałby wydany w .NET Core 2.1.0.

Blogu wyjaśnił błąd i jak go naprawiłem.

Jeśli stworzysz D2 w ten sposób

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

to prawda.

jeśli tak to zrobisz

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

To wciąż fałsz.

I t wydaje się, że to fałsz, jeśli struktura posiada tylko podwaja.

Musi to być zero, ponieważ zmiana linii

dd = -0,0

do:

dd = 0,0

powoduje, że porównanie jest prawdziwe ...