¿Puede alguien explicar este extraño comportamiento con flotadores firmados en C#?

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 sobre CanCompareBits, que ValueType.Equals utiliza para determinar si usar memcmp-comparación de estilo:

El comentario de CanCompareBits dice "Devuelve true si el valuetype no contener puntero y es firmemente lleno". Y Uso rápido de Qualscheck "memcmp" para acelerar la comparación.

El autor continúa indique 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 los lo mismo, pero el binario subyacente la representación es diferente. Si anida otra estructura que anula el método Igual, esa optimización también fallará.

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

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

Desafortunadamente, como hemos visto aquí, eso introduce una diferencia semántica porque la comparación bit a bit de dobles e Igual a la comparación de 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 tanto CanCompareBits() como FastEquals() (ambos métodos estáticos) son externos ([MethodImpl(MethodImplOptions.InternalCall)]) y no tienen fuente disponible.

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

hace dar verdadero para mí, con Mono gmcs 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 flotadores, 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.0 debe diferir de -0.0 solo por el bit de señal.

{¿qué piensas de esto?

Siempre sobrescribe 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 corregido (Descargo de responsabilidad: Soy el autor de este PR) en.NET Core que probablemente se publicaría en. NET Core 2.1.0.

La entrada del blog explicó el error y cómo lo arreglé.

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.

it parece que es falso si la estructura solo contiene dobles.

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

D. d = -0.0

A:

D. d = 0,0

Resulta que la comparación es verdadera...