Mengapa C # gagal membandingkan dua tipe objek satu sama lain tetapi VB tidak?

Saya memiliki dua objek di C # dan tidak tahu apakah itu Boolean atau tipe lainnya. Namun ketika saya mencoba membandingkan C # gagal memberikan jawaban yang benar. Saya telah mencoba kode yang sama dengan VB.NET dan berhasil!

Adakah yang bisa memberitahu saya cara memperbaikinya jika ada solusi?

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

Dalam C #, ==operator (ketika diterapkan pada ekspresi tipe referensi) melakukan pemeriksaan kesetaraan referensi kecuali itu kelebihan beban . Anda membandingkan dua referensi yang merupakan hasil konversi tinju, jadi itu adalah referensi yang berbeda.

Suntingan: Dengan tipe yang overload ==, Anda bisa mendapatkan perilaku yang berbeda - tapi itu didasarkan pada tipe waktu kompilasi dari ekspresi. Misalnya, stringberikan ==(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

Di sini perbandingan pertama menggunakan operator kelebihan beban, tetapi yang kedua menggunakan perbandingan referensi "default".

Dalam VB, =operator melakukan lebih banyak pekerjaan - bahkan tidak setara dengan menggunakan object.Equals(x, y), karena hal-hal seperti Option Comparedapat mempengaruhi bagaimana teks dibandingkan.

Pada dasarnya operator tidak bekerja dengan cara yang sama dan tidak dimaksudkan untuk bekerja dengan cara yang sama.

Selain jawaban Jon yang menjelaskan sisi C #, inilah yang dilakukan VB:

Dalam VB dengan Option Strict On, perbandingan melalui = selalu menguji kesetaraan nilai dan tidak pernah untuk kesetaraan referensi. Bahkan, kode Anda bahkan tidak dapat dikompilasi setelah Anda beralih Option Strict Onkarena System.Objecttidak mendefinisikan Operator=. Anda harus selalu memiliki opsi ini, itu menangkap bug lebih efektif daripada penangkap lalat venus (meskipun dalam kasus khusus Anda perilaku longgar ini benar-benar melakukan hal yang benar). ¹

Bahkan, dengan Option Strict On, VB berperilaku lebih ketat daripada C #: Dalam C #, a == b baik memicu panggilan ke SomeType.operator==(a, b)atau, jika ini tidak ada, meminta referensi perbandingan kesetaraan (yang setara dengan panggilan object.ReferenceEquals(a, b)).

Di VB di sisi lain, perbandingan a = b selalu memanggil operator kesetaraan. ² Jika Anda ingin menggunakan perbandingan kesetaraan referensi, Anda harus menggunakan a Is b(yang, sekali lagi, sama dengan Object.ReferenceEquals(a, b)).

¹⁾ Berikut ini indikasi bagus mengapa menggunakanOption Strict Off adalah ide yang buruk: Saya sudah VB.NET digunakan selama hampir satu dekade, dari sebelum rilis resmi NET sampai beberapa tahun yang lalu, dan saya sudah benar-benar tidak tahu apa yang a = bdilakukannya dengan Option Strict Off. Ia melakukan semacam perbandingan kesetaraan, tetapi apa yang sebenarnya terjadi dan mengapa, tidak tahu. Ini lebih kompleks daripada fitur C # dynamic, (karena itu bergantung pada API yang terdokumentasi dengan baik). Inilah yang dikatakan MSDN:

Karena Option Strict Onmemberikan pengetikan yang kuat , mencegah konversi tipe yang tidak diinginkan dengan kehilangan data, melarang pengikatan yang terlambat, dan meningkatkan kinerja, penggunaannya sangat disarankan.

²⁾ Jon telah menyebutkan satu pengecualian, string, di mana perbandingan kesetaraan melakukan beberapa hal lagi untuk alasan kompatibilitas mundur.

Instans objek tidak dibandingkan dengan operator "==". Anda harus menggunakan metode "sama dengan". Dengan "==" operator membandingkan referensi, bukan objek.

Coba ini:

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

Hasil:

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

Sekarang, coba ini:

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

Hasil:

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

Masalahnya adalah bahwa operator == di C # adalah panggilan ke metode statis (well, mungkin tidak secara teknis, tetapi bisa juga seperti itu) berdasarkan jenis waktu kompilasi dari dua parameter. Apa tipe runtime aktual dari objek-objek itu tidak penting.

Berdasarkan tipe waktu kompilasi itu kompiler akan menentukan implementasi apa yang operator ==akan digunakan. Mungkin menggunakan defaultobject implementasi , mungkin menggunakan salah satu kelebihan numerik yang disediakan oleh bahasa, atau bisa juga implementasi yang ditentukan pengguna.

Ini berbeda dari VB karena VB tidak menentukan implementasi pada waktu kompilasi. Ia menunggu sampai runtime dan memeriksa dua parameter yang diberikan untuk menentukan implementasi ==operator yang harus digunakan.

Kode Anda mengandung nilai boolean, tetapi mereka berada dalam variabel yang bertipe object. Karena variabel bertipe object, kompiler C # menggunakan objectimplementasi ==, yang membandingkan referensi , bukan instance objek. Karena nilai boolean adalah kotak, mereka tidak memiliki referensi yang sama, meskipun nilainya sama.

Kode VB tidak peduli apa jenis variabelnya. Itu menunggu sampai runtime dan kemudian memeriksa dua variabel, melihat bahwa mereka sebenarnya dari kedua jenis boolean, dan menggunakan ==implementasi operator boolean . Implementasi itu membandingkan nilai-nilai boolean, bukan referensi mereka (dan boolean akan dibuka kotaknya sebelum memanggil panggilan operator itu, sehingga perbandingan referensi bahkan tidak masuk akal lagi). Karena nilai-nilai boolean sama, itu mengembalikan nilai true.