Bất cứ ai cũng có thể giải thích hành vi kỳ lạ này với số float đã ký trong C #?

Dưới đây là ví dụ với ý kiến:

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

Vậy, bạn nghĩ gì về điều này?

Lỗi nằm ở hai dòng System.ValueTypesau: (Tôi bước vào nguồn tham khảo)

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

(Cả hai phương pháp là [MethodImpl(MethodImplOptions.InternalCall)])

Khi tất cả các trường có chiều rộng 8 byte, CanCompareBitstrả về nhầm là true, dẫn đến so sánh bitwise của hai giá trị khác nhau, nhưng giống hệt nhau về mặt ngữ nghĩa.

Khi có ít nhất một trường không rộng 8 byte, CanCompareBitstrả về false và mã tiến hành sử dụng phản xạ để lặp qua các trường và gọi Equalscho mỗi giá trị, xử lý chính xác -0.0bằng 0.0.

Đây là nguồn cho CanCompareBitstừ 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

Tôi đã tìm thấy câu trả lời tại http://bloss.msdn.com/xiangfan/archive/2008/09/01/magic-behind-valuetype-equals.aspx .

Phần cốt lõi là nhận xét nguồn CanCompareBits, ValueType.Equalssử dụng để xác định xem có nên sử dụng memcmpso sánh kiểu hay không:

Nhận xét của CanCompareBits cho biết "Trả về đúng nếu giá trị không chứa con trỏ và được đóng gói chặt chẽ". Và FastEqualsCheck sử dụng "memcmp" để tăng tốc độ so sánh.

Tác giả tiếp tục nêu chính xác vấn đề được mô tả bởi OP:

Hãy tưởng tượng bạn có một cấu trúc chỉ chứa một cái phao. Điều gì sẽ xảy ra nếu một cái chứa +0.0 và cái kia chứa -0.0? Chúng nên giống nhau, nhưng biểu diễn nhị phân cơ bản là khác nhau. Nếu bạn lồng cấu trúc khác ghi đè phương thức Equals, tối ưu hóa đó cũng sẽ thất bại.

Phỏng đoán của Vilx là đúng. "CanCompareBits" làm gì là kiểm tra xem liệu loại giá trị được đề cập có "được đóng gói chặt chẽ" trong bộ nhớ hay không. Một cấu trúc đóng gói chặt chẽ được so sánh bằng cách đơn giản so sánh các bit nhị phân tạo nên cấu trúc; một cấu trúc đóng gói lỏng lẻo được so sánh bằng cách gọi Equals trên tất cả các thành viên.

Điều này giải thích cho quan sát của SLaks rằng nó lặp lại với các cấu trúc đều tăng gấp đôi; cấu trúc như vậy luôn luôn được đóng gói chặt chẽ.

Thật không may như chúng ta đã thấy ở đây, điều đó giới thiệu một sự khác biệt về ngữ nghĩa bởi vì so sánh bitwise của phép nhân đôi và so sánh bằng nhau cho kết quả khác nhau.

Một nửa câu trả lời:

Reflector cho chúng ta biết rằng ValueType.Equals()làm một cái gì đó như thế này:

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

Thật không may, cả hai CanCompareBits()và FastEquals()(cả hai phương thức tĩnh) đều là extern ( [MethodImpl(MethodImplOptions.InternalCall)]) và không có nguồn nào khả dụng.

Quay lại để đoán tại sao một trường hợp có thể được so sánh bằng bit và trường hợp khác không thể (vấn đề căn chỉnh có thể?)

Điều đó đúng với tôi, với gmcs 2.4.2.3 của Mono.

Trường hợp thử nghiệm đơn giản hơn:

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 : Lỗi cũng xảy ra với float, nhưng chỉ xảy ra nếu các trường trong struct thêm tối đa 8 byte.

Nó phải liên quan đến so sánh từng bit một, vì 0.0chỉ khác nhau -0.0bởi bit tín hiệu.

…bạn nghĩ gì về điều này?

Luôn ghi đè bằng và GetHashCode trên các loại giá trị. Nó sẽ nhanh và chính xác.

Chỉ là một bản cập nhật cho lỗi 10 năm tuổi này: nó đã được sửa ( Tuyên bố miễn trừ trách nhiệm : Tôi là tác giả của PR này) trong .NET Core có thể sẽ được phát hành trong .NET Core 2.1.0.

Bài đăng trên blog đã giải thích lỗi và cách tôi sửa nó.

Nếu bạn làm D2 như thế này

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

đúng rồi.

nếu bạn làm nó như thế này

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

Nó vẫn sai.

Tôi dường như sai nếu cấu trúc chỉ giữ gấp đôi.

Nó phải là không liên quan, kể từ khi thay đổi dòng

đ = -0,0

đến:

đ = 0,0

kết quả so sánh là đúng ...