Alguém pode explicar esse comportamento estranho com carros alegóricos assinados em c #?

Aqui está o exemplo com comentários:

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

Então, o que você pensa sobre isso?

O erro está nas duas linhas a seguir System.ValueType: (Entrei na fonte de referência)

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

(Ambos os métodos são [MethodImpl(MethodImplOptions.InternalCall)])

Quando todos os campos têm 8 bytes de largura, CanCompareBitsretorna true por engano, resultando em uma comparação bit a bit de dois valores diferentes, mas semanticamente idênticos.

Quando pelo menos um campo não tem 8 bytes de largura, CanCompareBitsretorna false e o código continua a usar a reflexão para fazer um loop sobre os campos e chamar Equalscada valor, que é corretamente tratado -0.0como igual a 0.0.

Aqui está a fonte CanCompareBitsdo 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

Encontrei a resposta em http://blogs.msdn.com/xiangfan/archive/2008/09/01/magic-behind-valuetype-equals.aspx .

A peça principal é o comentário da fonte CanCompareBits, que é ValueType.Equalsusado para determinar se é usada a memcmpcomparação de estilo:

O comentário de CanCompareBits diz "Retornar verdadeiro se o tipo de valor não contiver ponteiro e estiver compactado". E o FastEqualsCheck usa "memcmp" para acelerar a comparação.

O autor continua declarando exatamente o problema descrito pelo OP:

Imagine que você tem uma estrutura que contém apenas um flutuador. O que ocorrerá se um contiver +0,0 e o outro contiver -0,0? Eles devem ser os mesmos, mas a representação binária subjacente é diferente. Se você aninhar outra estrutura que substitua o método Equals, essa otimização também falhará.

A conjectura de Vilx está correta. O que "CanCompareBits" faz é verificar se o tipo de valor em questão está "compactado" na memória. Uma estrutura compactada é comparada simplesmente comparando os bits binários que compõem a estrutura; uma estrutura fracamente compacta é comparada chamando Igual a todos os membros.

Isso explica a observação de SLaks de que ele é reprogramado com estruturas que são todas duplas; tais estruturas são sempre bem compactadas.

Infelizmente, como vimos aqui, isso introduz uma diferença semântica porque a comparação bit a bit de duplas e a comparação igual de duplas fornece resultados diferentes.

Meia resposta:

Refletor nos diz que ValueType.Equals()faz algo parecido com isto:

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

Infelizmente, ambos CanCompareBits()e FastEquals()(ambos os métodos estáticos) são externos ( [MethodImpl(MethodImplOptions.InternalCall)]) e não têm fonte disponível.

Voltando a adivinhar por que um caso pode ser comparado por bits e o outro não (problemas de alinhamento, talvez?)

Isso é verdadeiro para mim, com os gmcs do Mono 2.4.2.3.

Caso de teste mais simples:

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

EDIT : O bug também acontece com carros alegóricos, mas só acontece se os campos na estrutura somam um múltiplo de 8 bytes.

Ele deve estar relacionado à comparação pouco a pouco, pois 0.0deve diferir -0.0apenas do bit de sinal.

…o que você pensa sobre isso?

Sempre substitua Equals e GetHashCode nos tipos de valor. Será rápido e correto.

Apenas uma atualização para esse bug de 10 anos: foi corrigida ( Isenção de responsabilidade : sou o autor deste PR) no .NET Core, que provavelmente seria lançado no .NET Core 2.1.0.

A postagem do blog explicou o erro e como eu o corrigi.

Se você faz D2 assim

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

é verdade.

se você faz assim

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

Ainda é falso.

i t parece que é falso se a estrutura só tem duplos.

Deve ser zero, pois alterar a linha

dd = -0,0

para:

dd = 0,0

resulta na comparação verdadeira ...