C # perbedaan antara == dan Equals ()

Saya memiliki kondisi dalam aplikasi silverlight yang membandingkan 2 string, untuk beberapa alasan ketika saya menggunakannya ==mengembalikan false sementara .Equals()mengembalikan true .

Ini kodenya:

if (((ListBoxItem)lstBaseMenu.SelectedItem).Content.Equals("Energy Attack"))
{
    // Execute code
}

if (((ListBoxItem)lstBaseMenu.SelectedItem).Content == "Energy Attack")
{
    // Execute code
}

Ada alasan mengapa ini terjadi?

Ketika ==digunakan pada ekspresi tipe object, itu akan berubah menjadi System.Object.ReferenceEquals.

Equalshanyalah sebuah virtualmetode dan berperilaku seperti itu, sehingga versi yang diganti akan digunakan (yang, untuk stringtipe membandingkan konten).

Ketika membandingkan referensi objek ke string (bahkan jika referensi objek mengacu pada string), perilaku khusus ==operator khusus untuk kelas string diabaikan.

Biasanya (ketika tidak berurusan dengan string, yaitu), Equalsmembandingkan nilai , sambil ==membandingkan referensi objek . Jika dua objek yang Anda bandingkan merujuk ke instance yang persis sama dari suatu objek, maka keduanya akan mengembalikan true, tetapi jika seseorang memiliki konten yang sama dan berasal dari sumber yang berbeda (adalah instance terpisah dengan data yang sama), hanya Equals yang akan kembali benar. Namun, seperti yang disebutkan dalam komentar, string adalah kasus khusus karena menimpa ==operator sehingga ketika berurusan murni dengan referensi string (dan bukan referensi objek), hanya nilai yang dibandingkan bahkan jika mereka adalah contoh yang terpisah. Kode berikut menggambarkan perbedaan perilaku yang halus:

string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s3), s1 == s3, s1.Equals(s3));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s4), s1 == s4, s1.Equals(s4));

Outputnya adalah:

True True True
False True True
False False True

==dan .Equalskeduanya tergantung pada perilaku yang ditentukan dalam tipe aktual dan tipe aktual di situs panggilan. Keduanya hanya metode / operator yang dapat ditimpa pada jenis apa pun dan diberi perilaku yang diinginkan penulis. Dalam pengalaman saya, saya menemukan itu biasa bagi orang untuk mengimplementasikan .Equalspada suatu objek tetapi mengabaikan untuk mengimplementasikan operator ==. Ini berarti bahwa .Equalssebenarnya akan mengukur kesetaraan nilai sementara ==akan mengukur apakah mereka adalah referensi yang sama atau tidak.

Ketika saya bekerja dengan tipe baru yang definisinya dalam fluks atau menulis algoritma generik, saya menemukan praktik terbaik adalah sebagai berikut

• Jika saya ingin membandingkan referensi dalam C #, saya menggunakan Object.ReferenceEqualslangsung (tidak diperlukan dalam kasus umum)
• Jika saya ingin membandingkan nilai yang saya gunakan EqualityComparer<T>.Default

Dalam beberapa kasus ketika saya merasa penggunaan ==ambigu saya secara eksplisit akan menggunakan Object.Referenceequals dalam kode untuk menghapus ambiguitas.

Eric Lippert baru-baru ini membuat posting blog tentang masalah mengapa ada 2 metode kesetaraan di CLR. Ini layak dibaca

• http://blogs.msdn.com/ericlippert/archive/2009/04/09/double-your-dispatch-double-your-fun.aspx

== Operator

1. Jika operan adalah Tipe Nilai dan nilainya sama, ia mengembalikan true else false.
2. Jika operan adalah Tipe Referensi dengan pengecualian string dan keduanya merujuk ke instance yang sama (objek yang sama), itu mengembalikan true else false.
3. Jika operan adalah tipe string dan nilainya sama, ia mengembalikan true else false.

. Sama dengan

1. Jika operan adalah Jenis Referensi , ia melakukan Referensi Kesetaraan yaitu jika keduanya merujuk ke instance yang sama (objek yang sama), ia mengembalikan true else false.
2. Jika Operand adalah Jenis Nilai maka tidak seperti operator == ia memeriksa jenisnya terlebih dahulu dan jika jenisnya sama, ia melakukan == operator lain jika ia mengembalikan false.

Pertama, ada adalah perbedaan. Untuk angka

> 2 == 2.0
True

> 2.Equals(2.0)
False

Dan untuk string

> string x = null;
> x == null
True

> x.Equals(null)
NullReferenceException

Dalam kedua kasus, ==berperilaku lebih bermanfaat daripada.Equals

Sejauh yang saya mengerti jawabannya sederhana:

1. == membandingkan referensi objek.
2. .Equals membandingkan konten objek.
3. String tipe data selalu bertindak seperti perbandingan konten.

Saya harap saya benar dan itu menjawab pertanyaan Anda.

Saya akan menambahkan bahwa jika Anda melemparkan objek Anda ke string maka itu akan berfungsi dengan benar. Inilah sebabnya mengapa kompiler akan memberi Anda peringatan yang mengatakan:

Kemungkinan perbandingan referensi yang tidak diinginkan; untuk mendapatkan perbandingan nilai, masukkan sisi kiri untuk mengetik 'string'

Karena versi statis dari .Equalmetode ini tidak disebutkan sejauh ini, saya ingin menambahkan ini di sini untuk meringkas dan membandingkan 3 variasi.

MyString.Equals("Somestring"))          //Method 1
MyString == "Somestring"                //Method 2
String.Equals("Somestring", MyString);  //Method 3 (static String.Equals method) - better

di mana MyStringvariabel yang berasal dari tempat lain dalam kode.

Info latar belakang dan musim panas:

Di Jawa menggunakan ==untuk membandingkan string tidak boleh digunakan. Saya menyebutkan ini jika Anda perlu menggunakan kedua bahasa dan juga untuk memberi tahu Anda bahwa penggunaan ==juga dapat diganti dengan sesuatu yang lebih baik di C #.

Dalam C # tidak ada perbedaan praktis untuk membandingkan string menggunakan Metode 1 atau Metode 2 selama keduanya adalah tipe string. Namun, jika satu adalah nol, satu dari jenis lain (seperti bilangan bulat), atau satu mewakili objek yang memiliki referensi berbeda, maka, seperti yang ditunjukkan pertanyaan awal, Anda mungkin mengalami bahwa membandingkan konten untuk kesetaraan mungkin tidak menghasilkan apa kamu mengharapkan.

Solusi yang disarankan:

Karena menggunakan ==tidak persis sama dengan menggunakan .Equalssaat membandingkan sesuatu, Anda dapat menggunakan metode String.Equals statis sebagai gantinya. Dengan cara ini, jika kedua belah pihak bukan tipe yang sama Anda masih akan membandingkan konten dan jika salah satu adalah nol, Anda akan menghindari pengecualian.

   bool areEqual = String.Equals("Somestring", MyString);  

Memang sedikit lebih untuk menulis, tetapi menurut saya, lebih aman digunakan.

Berikut ini beberapa info yang disalin dari Microsoft:

public static bool Equals (string a, string b);

Parameter

a Tali

String pertama yang dibandingkan, atau null.

b Tali

String kedua untuk membandingkan, atau null.

Kembali Boolean

truejika nilai asama dengan nilai b; jika tidak false,. Jika keduanya adan bini null, metode kembali true.

Sama seperti tambahan untuk jawaban yang sudah baik: Perilaku ini TIDAK terbatas pada String atau membandingkan berbagai tipe angka. Bahkan jika kedua elemen tersebut bertipe objek dengan tipe dasar yang sama. "==" tidak akan berfungsi.

Tangkapan layar berikut menunjukkan hasil membandingkan dua objek {int} - nilai

Saya agak bingung di sini. Jika tipe runtime dari Konten adalah tipe string, maka == dan Persamaan harus mengembalikan true. Namun, karena hal ini tampaknya tidak terjadi, maka jenis runtime dari Konten bukan string dan memanggil Persamaan di atasnya sedang melakukan kesetaraan referensial dan ini menjelaskan mengapa Persamaan ("Serangan Energi") gagal. Namun, dalam kasus kedua, keputusan tentang overloaded == operator statis harus dipanggil dibuat pada waktu kompilasi dan keputusan ini tampaknya == (string, string). ini menunjukkan kepada saya bahwa Konten menyediakan konversi tersirat ke string.

Ada dimensi lain dari jawaban sebelumnya oleh @BlueMonkMN. Dimensi tambahan adalah bahwa jawaban untuk pertanyaan judul @ Drahcir seperti yang dinyatakan juga tergantung pada bagaimana kita sampai pada stringnilainya. Menggambarkan:

string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;
string s5 = "te" + "st";
object s6 = s5;
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2));

Console.WriteLine("\n  Case1 - A method changes the value:");
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s3), s1 == s3, s1.Equals(s3));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s4), s1 == s4, s1.Equals(s4));

Console.WriteLine("\n  Case2 - Having only literals allows to arrive at a literal:");
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s5), s1 == s5, s1.Equals(s5));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s6), s1 == s6, s1.Equals(s6));

Outputnya adalah:

True True True

  Case1 - A method changes the value:
False True True
False False True

  Case2 - Having only literals allows to arrive at a literal:
True True True
True True True

Menambahkan satu poin lagi ke jawabannya.

.EqualsTo() Metode memberi Anda ketentuan untuk membandingkan dengan budaya dan case sensitif.

The ==token C # digunakan untuk dua operator kesetaraan-cek yang berbeda. Ketika kompiler menemukan token itu, itu akan memeriksa apakah salah satu jenis yang dibandingkan telah menerapkan kelebihan operator-kesetaraan untuk salah satu jenis kombinasi spesifik yang sedang dibandingkan (*), atau untuk kombinasi jenis yang kedua jenis dapat dikonversi. Jika kompiler menemukan kelebihan seperti itu, ia akan menggunakannya. Jika tidak, jika kedua tipe tersebut adalah tipe referensi dan mereka bukan kelas yang tidak terkait (bisa berupa antarmuka, atau mungkin kelas terkait), kompiler akan dianggap ==sebagai operator perbandingan-referensi. Jika tidak ada ketentuan yang berlaku, kompilasi akan gagal.

Perhatikan bahwa beberapa bahasa lain menggunakan token terpisah untuk dua operator pemeriksa kesetaraan. Di VB.NET, misalnya, =token digunakan dalam ekspresi semata-mata untuk operator pemeriksa kesetaraan yang kelebihan beban, dan Isdigunakan sebagai operator uji-referensi atau null-test. Suatu untuk digunakan =pada suatu tipe yang tidak mengesampingkan operator pemeriksa kesetaraan akan gagal, sebagaimana akan berusaha digunakan Isuntuk tujuan apa pun selain menguji kesetaraan referensi atau nolitas.

(*) Jenis umumnya hanya kelebihan beban kesetaraan untuk dibandingkan dengan mereka sendiri, tetapi mungkin berguna untuk jenis kelebihan beban operator kesetaraan untuk perbandingan dengan jenis tertentu lainnya; misalnya, intdapat memiliki (dan IMHO seharusnya tetapi tidak) mendefinisikan operator kesetaraan untuk perbandingan float, sehingga 16777217 tidak akan melaporkan dirinya sama dengan 16777216f. Karena, karena tidak ada operator yang didefinisikan, C # akan mempromosikan intke float, membulatkannya ke 16777216f sebelum operator pemeriksa kesetaraan melihatnya; operator itu kemudian melihat dua angka floating-point yang sama dan melaporkannya sebagai sama, tidak mengetahui pembulatan yang terjadi.

Jawaban dan contoh yang sangat bagus!

Saya hanya ingin menambahkan perbedaan mendasar antara keduanya,

Operator seperti ==tidak polimorfik, sementara Equalsitu

Dengan konsep itu dalam pikiran, jika Anda menemukan contoh apa pun (dengan melihat jenis referensi tangan kiri dan kanan, dan memeriksa / mengetahui apakah jenisnya benar-benar memiliki == operator kelebihan beban dan Persamaan ditimpa) Anda yakin untuk mendapatkan jawaban yang benar .

Ketika kita membuat objek apa pun ada dua bagian untuk objek yang satu adalah konten dan yang lainnya adalah referensi untuk konten itu. ==membandingkan konten dan referensi; equals()hanya membandingkan konten

http://www.codeproject.com/Articles/584128/Apa-adalah-perbedaan- antara antara-samaandengan-dan-Eq

==

Operator == dapat digunakan untuk membandingkan dua variabel apa pun, dan itu hanya membandingkan bit .

int a = 3;
byte b = 3;
if (a == b) { // true }

Catatan: ada lebih banyak nol di sisi kiri int tetapi kami tidak peduli tentang itu di sini.

int a (00000011) == byte b (00000011)

Ingat operator == hanya peduli tentang pola bit dalam variabel.

Gunakan == Jika dua referensi (primitif) merujuk ke objek yang sama di heap.

Aturannya sama apakah variabelnya adalah referensi atau primitif.

Foo a = new Foo();
Foo b = new Foo();
Foo c = a;

if (a == b) { // false }
if (a == c) { // true }
if (b == c) { // false }

a == c benar a == b salah

pola bit sama untuk a dan c, sehingga keduanya sama dengan menggunakan ==.

Sama():

Gunakan metode equals () untuk melihat apakah dua objek berbeda sama .

Seperti dua objek String yang berbeda yang keduanya mewakili karakter dalam "Jane"

Satu-satunya perbedaan antara Equal dan == adalah pada perbandingan jenis objek. dalam kasus lain, seperti jenis referensi dan jenis nilai, mereka hampir sama (baik keduanya adalah kesetaraan bit-bijaksana atau keduanya adalah persamaan referensi).

objek: Persamaan: bit-wise equality ==: reference equality

string: (sama dengan dan == sama untuk string, tetapi jika salah satu string berubah menjadi objek, maka hasil perbandingan akan berbeda) Persamaan: bit-wise equality ==: bit-wise equality

Lihat di sini untuk penjelasan lebih lanjut.