¿Alguien puede explicar este extraño comportamiento con flotadores firmados en C #?

Aquí está el ejemplo con comentarios:

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

Entonces, ¿qué te parece esto?

El error está en las siguientes dos líneas de System.ValueType: (Entré en la fuente de referencia)

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

(Ambos métodos son [MethodImpl(MethodImplOptions.InternalCall)])

Cuando todos los campos tienen 8 bytes de ancho, por CanCompareBitserror devuelve verdadero, lo que resulta en una comparación bit a bit de dos valores diferentes, pero semánticamente idénticos.

Cuando al menos un campo no tiene 8 bytes de ancho, CanCompareBitsdevuelve falso, y el código continúa usando la reflexión para recorrer los campos y llamar Equalsa cada valor, que se trata correctamente -0.0como igual a 0.0.

Aquí está la fuente CanCompareBitsde 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

Encontré la respuesta en http://blogs.msdn.com/xiangfan/archive/2008/09/01/magic-behind-valuetype-equals.aspx .

La pieza central es el comentario fuente CanCompareBits, que se ValueType.Equalsusa para determinar si se debe usar la memcmpcomparación de estilos:

El comentario de CanCompareBits dice "Devuelve verdadero si el valuetype no contiene puntero y está muy empaquetado". Y FastEqualsCheck usa "memcmp" para acelerar la comparación.

El autor continúa exponiendo exactamente el problema descrito por el OP:

Imagina que tienes una estructura que solo contiene un flotador. ¿Qué ocurrirá si uno contiene +0.0 y el otro contiene -0.0? Deberían ser iguales, pero la representación binaria subyacente es diferente. Si anida otra estructura que anula el método Equals, esa optimización también fallará.

La conjetura de Vilx es correcta. Lo que hace "CanCompareBits" es verificar si el tipo de valor en cuestión está "apretado" en la memoria. Una estructura apretada se compara simplemente comparando los bits binarios que componen la estructura; una estructura compacta se compara llamando a Equals en todos los miembros.

Esto explica la observación de SLaks de que repros con estructuras que son todas dobles; tales estructuras siempre están apretadas.

Desafortunadamente, como hemos visto aquí, eso introduce una diferencia semántica porque la comparación bit a bit de dobles y la comparación igual a dobles da resultados diferentes.

Media respuesta:

Reflector nos dice que ValueType.Equals()hace algo como esto:

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

Desafortunadamente, ambos CanCompareBits()y FastEquals()(ambos métodos estáticos) son externos ([MethodImpl(MethodImplOptions.InternalCall)] ) y no tienen una fuente disponible.

Volviendo a adivinar por qué un caso puede ser comparado por bits, y el otro no (¿problemas de alineación tal vez?)

Que no dan cierto para mí, la GMC de Mono 2.4.2.3.

Caso de prueba más simple:

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

EDITAR : El error también ocurre con flotantes, pero solo ocurre si los campos en la estructura suman un múltiplo de 8 bytes.

Debe estar relacionado con una comparación bit a bit, ya que 0.0debe diferir de -0.0solo el bit de señal.

…¿qué piensas sobre esto?

Siempre anule Equals y GetHashCode en los tipos de valor. Será rápido y correcto.

Solo una actualización para este error de 10 años: se ha solucionado ( Descargo de responsabilidad : soy el autor de este PR) en .NET Core que probablemente se lanzaría en .NET Core 2.1.0.

La publicación del blog explicaba el error y cómo lo solucioné.

Si haces D2 así

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

es verdad.

si lo haces así

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

Sigue siendo falso.

i t parece que es falso si la estructura sólo se mantiene dobles.

Debe estar relacionado con cero, ya que cambiar la línea

dd = -0.0

a:

dd = 0.0

da como resultado que la comparación sea verdadera ...