Herkes bu garip davranışı C # imzalı yüzen ile açıklayabilir?

İşte yorum içeren örnek:

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

Peki, bunun hakkında ne düşünüyorsun?

Hata aşağıdaki iki satırda System.ValueType: (Referans kaynağına adım attım)

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

(Her iki yöntem de [MethodImpl(MethodImplOptions.InternalCall)])

Tüm alanlar 8 bayt genişliğinde olduğunda, CanCompareBitsyanlışlıkla true değerini döndürerek iki farklı, ancak anlamsal olarak özdeş değerin bitsel olarak karşılaştırılmasına yol açar.

En az bir alan 8 bayt genişliğinde değilse, CanCompareBitsfalse değerini döndürür ve kod, alanlar üzerinde döngü oluşturmak ve Equalsher bir değeri çağırmak için yansıma kullanmaya devam eder ; bu, doğru -0.0olarak eşit kabul edilir 0.0.

CanCompareBitsSSCLI kaynak :

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

Cevabı http://blogs.msdn.com/xiangfan/archive/2008/09/01/magic-behind-valuetype-equals.aspx adresinde buldum .

Çekirdek parçası kaynak yorumdur CanCompareBits, ValueType.Equalskullanımı olup olmadığını belirlemek için kullanır memcmptarzı karşılaştırma:

CanCompareBits'in yorumu, "valueetype işaretçi içermiyorsa ve sıkıca paketlenmişse true döndürür" yazıyor. Ve FastEqualsCheck karşılaştırmayı hızlandırmak için "memcmp" kullanın.

Yazar, OP tarafından açıklanan sorunu tam olarak belirtmektedir:

Sadece şamandıra içeren bir yapıya sahip olduğunuzu düşünün. Biri +0.0, diğeri -0.0 içeriyorsa ne olur? Aynı olmalılar, ancak temeldeki ikili gösterim farklıdır. Eşittir yöntemini geçersiz kılan başka bir yapıyı iç içe yerleştirirseniz, bu optimizasyon da başarısız olur.

Vilx'in varsayımı doğrudur. "CanCompareBits" in yaptığı, söz konusu değer türünün bellekte "sıkıca paketlenmiş" olup olmadığını kontrol etmektir. Sıkı paketlenmiş bir yapı, sadece yapıyı oluşturan ikili bitleri karşılaştırarak karşılaştırılır; gevşek bir şekilde paketlenmiş bir yapı, tüm üyelere Eşittir çağrılarak karşılaştırılır.

Bu, SLaks'ın iki katına çıkan yapılarla karşı karşıya kaldığı gözlemini açıklar; bu tür yapılar her zaman sıkıca paketlenir.

Ne yazık ki burada gördüğümüz gibi, bu semantik bir fark getiriyor çünkü çiftlerin bitsel karşılaştırması ve çiftlerin eşit karşılaştırması farklı sonuçlar veriyor.

Yarım cevap:

Reflektör bize bunun ValueType.Equals()böyle bir şey yaptığını söyler :

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

Maalesef hem CanCompareBits()ve FastEquals()(her ikisi de statik yöntemleri) (extern olan [MethodImpl(MethodImplOptions.InternalCall)]) ve hiçbir kaynak var.

Bir vakanın neden bitlerle karşılaştırılabileceğini ve diğerinin yapamayacağını tahmin etmeye geri dönün (hizalama sorunları belki?)

Bu mu Mono GOK değerleri 2.4.2.3 ile, benim için doğrudur ver.

Daha basit test durumu:

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

DÜZENLEME : Hata aynı zamanda kayan noktalarda da olur, ancak yalnızca yapıdaki alanlar 8 baytın katlarına kadar eklenirse olur.

Sadece sinyal bitinden 0.0farklı olması gerektiğinden , biraz bit karşılaştırması ile ilgili olmalıdır -0.0.

…bunun hakkında ne düşünüyorsun?

Değer türlerinde her zaman Equals ve GetHashCode'u geçersiz kılın. Hızlı ve doğru olacak.

Bu 10 yıllık hata için sadece bir güncelleme: .NET Core 2.1.0'da yayınlanacak olan .NET Core'da düzeltildi ( Feragatname : Bu PR'nin yazarıyım).

Blog yazısı hata açıkladı ve nasıl düzelttim.

D2'yi böyle yaparsanız

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

bu doğru.

eğer böyle yaparsan

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

Hala yanlış.

i yapı sadece çiftler tutan eğer yanlış gibi t görünüyor.

Satırı değiştirdiğinden sıfır ile ilgili olmalıdır

gg = -0,0

için:

gg = 0.0

karşılaştırmanın doğru olduğu ...