Adakah yang bisa menjelaskan perilaku aneh ini dengan floats yang ditandatangani di C #?

Ini adalah contoh dengan komentar:

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

Jadi, apa pendapat Anda tentang ini?

Bug ada dalam dua baris berikut System.ValueType: (Saya masuk ke sumber referensi)

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

(Kedua metode tersebut adalah [MethodImpl(MethodImplOptions.InternalCall)])

Ketika semua bidang adalah 8 byte lebar, CanCompareBitssecara keliru mengembalikan nilai true, menghasilkan perbandingan bitwise dari dua nilai yang berbeda, tetapi identik secara semantik.

Ketika setidaknya satu bidang tidak lebar 8 byte, CanCompareBitsmengembalikan false, dan kode mulai menggunakan refleksi untuk mengulangi bidang dan memanggil Equalssetiap nilai, yang memperlakukan dengan benar -0.0sama dengan 0.0.

Berikut adalah sumber untuk CanCompareBitsdari 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

Saya menemukan jawabannya di http://blogs.msdn.com/xiangfan/archive/2008/09/01/magic-behind-valuetype-equals.aspx .

Bagian inti adalah sumber komentar CanCompareBits, yang ValueType.Equalsdigunakan untuk menentukan apakah akan menggunakan memcmpperbandingan-gaya:

Komentar dari CanCompareBits mengatakan "Return true jika valuetype tidak mengandung pointer dan sudah penuh". Dan FastEqualsCheck menggunakan "memcmp" untuk mempercepat perbandingan.

Penulis selanjutnya menyatakan dengan tepat masalah yang dijelaskan oleh OP:

Bayangkan Anda memiliki struktur yang hanya berisi pelampung. Apa yang akan terjadi jika satu berisi +0.0, dan yang lainnya berisi -0.0? Mereka harus sama, tetapi representasi biner yang mendasarinya berbeda. Jika Anda membuat struktur lain yang menimpa metode Persamaan, optimasi itu juga akan gagal.

Dugaan Vilx benar. Apa yang "CanCompareBits" lakukan adalah memeriksa untuk melihat apakah tipe nilai yang dimaksud "penuh sesak" dalam memori. Struct yang padat dibandingkan dengan hanya membandingkan bit biner yang membentuk struktur; struktur yang longgar dibandingkan dengan memanggil Equals pada semua anggota.

Ini menjelaskan pengamatan SLaks bahwa repros dengan struct yang semuanya berlipat ganda; struct seperti itu selalu penuh sesak.

Sayangnya seperti yang telah kita lihat di sini, itu memperkenalkan perbedaan semantik karena perbandingan bitwise dari double dan Equals perbandingan dari double memberikan hasil yang berbeda.

Setengah jawaban:

Reflector memberi tahu kami bahwa ValueType.Equals()melakukan sesuatu seperti ini:

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

Sayangnya keduanya CanCompareBits()dan FastEquals()(keduanya metode statis) adalah eksternal ( [MethodImpl(MethodImplOptions.InternalCall)]) dan tidak memiliki sumber yang tersedia.

Kembali ke menebak mengapa satu kasus dapat dibandingkan dengan bit, dan yang lainnya tidak dapat (masalah pelurusan mungkin?)

Itu memang benar bagi saya, dengan Monm gmcs 2.4.2.3.

Test case yang lebih sederhana:

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 : Bug ini juga terjadi dengan float, tetapi hanya terjadi jika bidang di struct menambahkan hingga kelipatan 8 byte.

Itu harus terkait dengan perbandingan sedikit demi sedikit, karena 0.0harus berbeda -0.0hanya dari sedikit sinyal.

... apa pendapatmu tentang ini?

Selalu menimpa Equals dan GetHashCode pada tipe nilai. Ini akan cepat dan benar.

Hanya pembaruan untuk bug berusia 10 tahun ini: telah diperbaiki ( Penafian : Saya penulis PR ini) dalam .NET Core yang mungkin akan dirilis dalam .NET Core 2.1.0.

The posting blog menjelaskan bug dan bagaimana saya tetap itu.

Jika Anda membuat D2 seperti ini

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

itu benar.

jika kamu membuatnya seperti ini

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

Itu masih salah.

i t tampaknya seperti itu false jika struct hanya memegang ganda.

Itu harus nol terkait, karena mengubah garis

dd = -0.0

untuk:

dd = 0,0

menghasilkan perbandingan yang benar ...