Tại sao C # không thể so sánh hai loại đối tượng với nhau nhưng VB thì không?

Tôi có hai đối tượng trong C # và không biết đó là Boolean hay bất kỳ loại nào khác. Tuy nhiên khi tôi cố gắng so sánh những C # đó không đưa ra câu trả lời đúng. Tôi đã thử mã tương tự với VB.NET và điều đó đã làm điều đó!

Bất cứ ai có thể cho tôi biết làm thế nào để khắc phục điều này nếu có một giải pháp?

C #:

object a = true;
object b = true;
object c = false;
if (a == b) c = true;
MessageBox.Show(c.ToString()); //Outputs False !!

VB.NET:

Dim a As Object = True
Dim b As Object = True
Dim c As Object = False
If (a = b) Then c = True
MessageBox.Show(c.ToString()) '// Outputs True

Trong C #, ==toán tử (khi được áp dụng cho các biểu thức kiểu tham chiếu) thực hiện kiểm tra đẳng thức tham chiếu trừ khi nó bị quá tải . Bạn đang so sánh hai tài liệu tham khảo là kết quả của chuyển đổi quyền anh, vì vậy đó là những tài liệu tham khảo riêng biệt.

EDIT: Với các loại quá tải ==, bạn có thể có các hành vi khác nhau - nhưng đó là dựa trên loại thời gian biên dịch của các biểu thức. Ví dụ: stringcung cấp ==(string, string):

string x = new string("foo".ToCharArray());
string y = new string("foo".ToCharArray());
Console.WriteLine(x == y); // True
Console.WriteLine((object) x == (object) y); // False

Ở đây so sánh đầu tiên là sử dụng toán tử quá tải, nhưng thứ hai là sử dụng so sánh tham chiếu "mặc định".

Trong VB, =toán tử thực hiện nhiều công việc hơn - nó thậm chí không tương đương với việc sử dụng object.Equals(x, y), vì những thứ như Option Comparecó thể ảnh hưởng đến cách so sánh văn bản.

Về cơ bản, các nhà khai thác không hoạt động theo cùng một cách và không có ý định làm việc theo cùng một cách.

Ngoài câu trả lời của Jon giải thích khía cạnh C # của mọi thứ, đây là những gì VB làm:

Trong VB với Option Strict On, một so sánh thông qua = luôn kiểm tra sự bằng nhau về giá trị và không bao giờ cho sự bình đẳng tham chiếu. Thực tế, mã của bạn thậm chí không biên dịch khi bạn chuyển đổi Option Strict Onbởi vìSystem.Object không xác định Operator=. Bạn nên luôn luôn có tùy chọn này, nó bắt lỗi hiệu quả hơn một con ruồi venus (mặc dù trong trường hợp cụ thể của bạn, hành vi lỏng lẻo này thực sự làm đúng). ¹

Trong thực tế, với Option Strict On, VB hành xử thậm chí còn nghiêm ngặt hơn C #: Trong C #,a == b hoặc kích hoạt một cuộc gọi đến SomeType.operator==(a, b)hoặc, nếu điều này không tồn tại, gọi phép so sánh đẳng thức tham chiếu (tương đương với gọi object.ReferenceEquals(a, b)).

Mặt khác, trong VB, phép so sánh a = b luôn gọi toán tử đẳng thức. ² Nếu bạn muốn sử dụng so sánh đẳng thức tham chiếu, bạn phải sử dụng a Is b(nghĩa là, một lần nữa, giống như Object.ReferenceEquals(a, b)).

¹⁾ Đây là một dấu hiệu tốt tại sao sử dụng Option Strict Offlà một ý tưởng tồi: Tôi đã sử dụng VB.NET trong gần một thập kỷ, từ trước khi phát hành chính thức của .NET cho đến vài năm trước, và tôi hoàn toàn không biếta = b phải làm gì Option Strict Off. Nó thực hiện một số loại so sánh bình đẳng, nhưng chính xác những gì xảy ra và tại sao, không có ý tưởng. Tuy nhiên, nó phức tạp hơn dynamictính năng của C # (vì điều đó phụ thuộc vào API được ghi chép tốt). Đây là những gì MSDN nói:

Vì Option Strict Oncung cấp kiểu gõ mạnh , ngăn chặn các chuyển đổi loại ngoài ý muốn bị mất dữ liệu, không tuân thủ ràng buộc muộn và cải thiện hiệu suất, nên sử dụng mạnh mẽ.

²⁾ Jon đã đề cập đến một ngoại lệ, các chuỗi, trong đó so sánh bình đẳng thực hiện một số điều nữa vì lý do tương thích ngược.

Các thể hiện đối tượng không được so sánh với toán tử "==". Bạn nên sử dụng phương pháp "bằng". Với toán tử "==" đang so sánh các tham chiếu, không phải các đối tượng.

Thử cái này:

public class MyObject
{
    public MyObject(String v)
    {
        Value = v;
    }
    public String Value { get; set; }
}

MyObject a = new MyObject("a");
MyObject b = new MyObject("a");
if(a==b){
    Debug.WriteLine("a reference is equal to b reference");
}else{
    Debug.WriteLine("a reference is not equal to b reference");
}
if (a.Equals(b)) {
    Debug.WriteLine("a object is equal to b object");
} else {
    Debug.WriteLine("a object is not equal to b object");
}

Các kết quả:

a reference is not equal to b reference
a object is not equal to b object

Bây giờ, hãy thử điều này:

public class MyObject
{
    public MyObject(String v)
    {
        Value = v;
    }
    public String Value { get; set; }

    public bool Equals(MyObject o)
    {
        return (Value.CompareTo(o.Value)==0);
    }
}
MyObject a = new MyObject("a");
MyObject b = new MyObject("a");
if(a==b){
    Debug.WriteLine("a reference is equal to b reference");
}else{
    Debug.WriteLine("a reference is not equal to b reference");
}
if (a.Equals(b)) {
    Debug.WriteLine("a object is equal to b object");
} else {
    Debug.WriteLine("a object is not equal to b object");
}

Các kết quả:

a reference is not equal to b reference
a object is equal to b object

Vấn đề là toán tử == trong C # là một cuộc gọi đến một phương thức tĩnh (tốt, có thể không phải về mặt kỹ thuật, nhưng nó có thể là như vậy) dựa trên loại thời gian biên dịch của hai tham số. Những kiểu thời gian chạy thực tế của những đối tượng đó không quan trọng.

Dựa trên kiểu thời gian biên dịch đó, trình biên dịch sẽ xác định việc triển khai operator ==sử dụng. Nó có thể sử dụng objecttriển khai mặc định , nó có thể sử dụng một trong các tình trạng quá tải số do ngôn ngữ cung cấp hoặc có thể là do người dùng xác định.

Điều này khác với VB ở chỗ VB không xác định việc thực hiện tại thời điểm biên dịch. Nó chờ cho đến khi thời gian chạy và kiểm tra hai tham số được đưa ra để xác định việc triển ==khai toán tử nào sẽ sử dụng.

Mã của bạn chứa các giá trị boolean, nhưng chúng nằm trong các biến có kiểu object. Bởi vì biến là kiểu object, trình biên dịch C # sử dụng việc objectthực hiện ==, so sánh các tham chiếu , không phải các thể hiện đối tượng. Vì các giá trị boolean là các hộp, chúng không có cùng tham chiếu, mặc dù các giá trị của chúng là như nhau.

Mã VB không quan tâm loại biến là gì. Nó đợi cho đến khi thực thi và sau đó kiểm tra hai biến, thấy rằng chúng thực sự thuộc cả hai loại boolean và do đó sử dụng toán ==tử boolean . Việc triển khai đó so sánh các giá trị của booleans, chứ không phải các tham chiếu của chúng (và các booleans sẽ được bỏ hộp trước khi gọi hàm toán tử đó, do đó, một so sánh tham chiếu thậm chí không còn ý nghĩa gì nữa). Bởi vì các giá trị của booleans là như nhau, nó trả về true.