Kann jemand dieses seltsame Verhalten mit signierten Floats in C # erklären?

Hier ist das Beispiel mit Kommentaren:

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

Sag mal, wie findest du das?

Der Fehler ist in den folgenden zwei Zeilen von System.ValueType: (Ich trat in die Referenzquelle)

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

(Beide Methoden sind [MethodImpl(MethodImplOptions.InternalCall)])

Wenn alle Felder 8 Byte breit sind, wird CanCompareBitsfälschlicherweise true zurückgegeben, was zu einem bitweisen Vergleich zweier verschiedener, aber semantisch identischer Werte führt.

Wenn mindestens ein Feld nicht 8 Byte breit ist, wird CanCompareBitsfalse zurückgegeben, und der Code verwendet die Reflexion, um die Felder zu durchlaufen und Equalsjeden Wert aufzurufen , der korrekt -0.0als gleich behandelt wird 0.0.

Hier ist die Quelle für 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

Ich fand die Antwort unter http://blogs.msdn.com/xiangfan/archive/2008/09/01/magic-behind-valuetype-equals.aspx .

Das Kernstück ist der Quellkommentar, anhand CanCompareBitsdessen ValueType.Equalsbestimmt wird, ob ein memcmpStilvergleich verwendet werden soll:

Der Kommentar von CanCompareBits lautet "Return true, wenn der Wertetyp keinen Zeiger enthält und dicht gepackt ist". Und FastEqualsCheck verwendet "memcmp", um den Vergleich zu beschleunigen.

Der Autor führt das vom OP beschriebene Problem genau an:

Stellen Sie sich vor, Sie haben eine Struktur, die nur einen Float enthält. Was passiert, wenn einer +0,0 und der andere -0,0 enthält? Sie sollten gleich sein, aber die zugrunde liegende binäre Darstellung ist unterschiedlich. Wenn Sie eine andere Struktur verschachteln, die die Equals-Methode überschreibt, schlägt diese Optimierung ebenfalls fehl.

Vilx 'Vermutung ist richtig. "CanCompareBits" prüft, ob der betreffende Werttyp im Speicher "dicht gepackt" ist. Eine dicht gepackte Struktur wird verglichen, indem einfach die Binärbits verglichen werden, aus denen die Struktur besteht. Eine lose gepackte Struktur wird verglichen, indem für alle Mitglieder Equals aufgerufen wird.

Dies erklärt die Beobachtung von SLaks, dass es sich um Strukturen handelt, die alle doppelt sind. solche Strukturen sind immer dicht gepackt.

Wie wir hier gesehen haben, führt dies leider zu einem semantischen Unterschied, da der bitweise Vergleich von Doppelwerten und der Gleichheitsvergleich von Doppelwerten unterschiedliche Ergebnisse liefert.

Eine halbe Antwort:

Der Reflektor sagt uns, dass er ValueType.Equals()so etwas macht:

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

Leider sind beide CanCompareBits()und FastEquals()(beide statische Methoden) extern ( [MethodImpl(MethodImplOptions.InternalCall)]) und haben keine Quelle zur Verfügung.

Zurück zur Vermutung, warum ein Fall mit Bits verglichen werden kann und der andere nicht (Ausrichtungsprobleme vielleicht?)

Es wird geben gilt für mich, mit Monos gmcs 2.4.2.3.

Einfacherer Testfall:

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

BEARBEITEN : Der Fehler tritt auch bei Floats auf, jedoch nur, wenn die Felder in der Struktur ein Vielfaches von 8 Bytes ergeben.

Es muss sich auf einen bitweisen Vergleich beziehen, da 0.0sich dieser -0.0nur durch das Signalbit unterscheiden sollte .

…was denkst du darüber?

Überschreiben Sie bei Werttypen immer Equals und GetHashCode. Es wird schnell und korrekt sein.

Nur ein Update für diesen 10 Jahre alten Fehler: Er wurde in .NET Core behoben ( Haftungsausschluss : Ich bin der Autor dieser PR) und wahrscheinlich in .NET Core 2.1.0 veröffentlicht.

Der Blog-Beitrag erklärte den Fehler und wie ich ihn behoben habe.

Wenn du D2 so machst

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

es ist wahr.

wenn du es so machst

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

Es ist immer noch falsch.

Es scheint falsch zu sein, wenn die Struktur nur Doubles enthält.

Es muss nullbezogen sein, da die Zeile geändert wird

dd = -0,0

zu:

dd = 0,0

führt dazu, dass der Vergleich wahr ist ...