== ve Eşittir () arasındaki C # farkı

Ben kullandığınızda nedense 2 dizeleri karşılaştıran bir Silverlight uygulamasında bir şartım var ==döndürür false iken .Equals()döner doğrudur .

İşte kod:

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

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

Bunun neden olduğuna dair bir sebep var mı?

Bir ==tür ifadesinde kullanıldığında, objectçözümlenir System.Object.ReferenceEquals.

Equalsyalnızca bir virtualyöntemdir ve böyle davranır, bu nedenle geçersiz kılınan sürüm kullanılır (bu, stringtür için içeriği karşılaştırır).

Bir nesne başvurusunu bir dizeyle karşılaştırırken (nesne başvurusu bir dizeye başvursa bile), ==dize sınıfına özgü operatörün özel davranışı yok sayılır.

(Olup dizeleri ile ilgili değildir) normal olarak, Equalskarşılaştırır değerleri ise, ==karşılaştırır nesne referanslar . Karşılaştırdığınız iki nesne bir nesnenin tam olarak aynı örneğine başvuruyorsa, her ikisi de true değerini döndürür, ancak biri aynı içeriğe sahipse ve farklı bir kaynaktan geliyorsa (aynı verilere sahip ayrı bir örnekse), yalnızca Eşittir doğru dön. Bununla birlikte, yorumlarda belirtildiği gibi, dize özel bir durumdur, çünkü ==operatörü geçersiz kılar, böylece yalnızca dize referanslarıyla (nesne referanslarıyla değil) uğraşırken, yalnızca ayrı örnekler olsalar bile değerler karşılaştırılır. Aşağıdaki kod, davranışlardaki küçük farklılıkları göstermektedir:

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

Çıktı:

True True True
False True True
False False True

==ve .Equalsher ikisi de gerçek sitede tanımlanan davranışa ve çağrı sitesindeki gerçek türe bağlıdır. Her ikisi de sadece herhangi bir türde geçersiz kılınabilen ve yazarın istediği herhangi bir davranışta bulunabilecek yöntem / işleçlerdir. Deneyimlerime göre, insanların .Equalsbir nesne üzerinde uygulama yapmasının yaygın olduğunu , ancak operatörü uygulamayı ihmal ettiğini görüyorum ==. Bu .Equals, aslında değerlerin eşitliğini ==ölçecek, aynı referans olup olmadıklarını ölçecek demektir.

Tanımı akı içinde olan veya genel algoritmalar yazan yeni bir türle çalışırken, en iyi uygulamanın aşağıdaki olduğunu düşünüyorum

• C # referansları karşılaştırmak istiyorsanız, Object.ReferenceEqualsdoğrudan kullanın (genel durumda gerekli değildir)
• Eğer kullandığım değerleri karşılaştırmak istersem EqualityComparer<T>.Default

Bazı durumlarda kullanımın ==belirsiz olduğunu düşündüğümde , belirsizliği Object.Referencekaldırmak için açıkça koddaki eşitleri kullanacağım .

Eric Lippert yakın zamanda CLR'de neden 2 eşitlik yöntemi olduğu konusunda bir blog yazısı yaptı. Okumaya değer

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

== Operatör

1. İşlenenler Değer Türleri ve değerleri eşitse, başka true değerini döndürür.
2. İşlenenler dize dışında Referans Türleriyse ve her ikisi de aynı örneğe (aynı nesne) başvuruyorsa , başka true değerini döndürür.
3. İşlenenler dize türüyse ve değerleri eşitse, başka true değerini döndürür.

.Equals

1. İşlenenler Referans Türleri ise, her ikisi de aynı örneğe (aynı nesneye) başvuruyorsa, Referans Eşitliği gerçekleştirir , aksi halde true değerini döndürür.
2. İşlenenler ise değer Türleri == operatörü aksine sonra kendi için denetler tip birinci ve onların türleri eğer başka aynı gerçekleştirdiği == operatörü yanlış döndürür vardır.

İlk olarak, var olan bir fark. Sayılar için

> 2 == 2.0
True

> 2.Equals(2.0)
False

Ve dizeler için

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

> x.Equals(null)
NullReferenceException

Her iki durumda da, ==daha yararlı daha davranır.Equals

Anladığım kadarıyla cevap basit:

1. == nesne referanslarını karşılaştırır.
2. .Equals nesne içeriğini karşılaştırır.
3. String veri türleri her zaman içerik karşılaştırması gibi davranır.

Umarım doğruyum ve sorunuzu cevaplamıştır.

Nesnenizi bir dizeye yayınlarsanız, düzgün çalışacağını ekleyeceğim. Bu yüzden derleyici size bir uyarı verecektir:

Olası istenmeyen referans karşılaştırması; değer karşılaştırması almak için sol tarafa 'dize' yazın

.EqualYöntemin statik sürümü şu ana kadar bahsedilmediğinden, bunu 3 varyasyonu özetlemek ve karşılaştırmak için buraya eklemek istiyorum.

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

Burada MyString, kodda başka bir yerden gelen bir değişken vardır.

Arka plan bilgisi ve yaza göre:

Java'da ==dizeleri karşılaştırmak için kullanılmamalıdır. Her iki dili de kullanmanız gerektiğinde ve ayrıca ==C # 'da kullanmanın daha iyi bir şeyle değiştirilebileceğini bildirmek için bunu belirtmiştim .

C # 'da, her ikisi de tür dizgisi olduğu sürece, Yöntem 1 veya Yöntem 2'yi kullanarak dizeleri karşılaştırmak için pratik bir fark yoktur. Bununla birlikte, biri boşsa, biri başka bir türdeyse (tamsayı gibi) ya da biri farklı bir referansa sahip bir nesneyi temsil eder, o zaman, ilk sorunun gösterdiği gibi, içeriği eşitlik için karşılaştırmanın neyi döndürmeyebileceğini deneyimleyebilirsiniz bekliyoruz.

Önerilen çözüm:

Kullanmak ==, .Equalsşeyleri karşılaştırırken kullanmakla tam olarak aynı olmadığından , bunun yerine statik String.Equals yöntemini kullanabilirsiniz . Bu şekilde, iki taraf aynı tür değilse, içeriği yine de karşılaştıracaksınız ve biri boşsa, istisnayı önleyeceksiniz.

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

Yazmak biraz daha fazla, ama bence kullanmak daha güvenli.

Microsoft'tan kopyalanan bazı bilgiler:

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

Parametreler

a sicim

Karşılaştırılacak ilk dize veya null.

b sicim

Karşılaştırılacak ikinci dize veya null.

İadeler Boolean

truedeğeri, değeri ile aaynı ise b; aksi takdirde false. Hem ave hem bde null, yöntem döndürülür true.

Zaten iyi yanıtlara ek olarak: Bu davranış Dizelerle veya farklı sayı türlerini karşılaştırmakla sınırlı DEĞİLDİR. Her iki öğe de aynı altta yatan türde bir nesne olsa bile. "==" çalışmaz.

Aşağıdaki ekran görüntüsü iki nesne {int} - değerinin karşılaştırılmasının sonuçlarını göstermektedir

Burada biraz kafam karıştı. İçeriğin çalışma zamanı türü dize türündeyse, hem == hem de Equals doğru dönmelidir. Ancak, bu durum böyle görünmediğinden, çalışma zamanı İçerik türü dize değildir ve buna eşittir çağrısı referans eşitliği yapıyor ve bu da Eşittir ("Enerji Saldırısı") neden başarısız olduğunu açıklıyor. Ancak, ikinci durumda, aşırı yüklenmiş == statik operatörün çağrılması gerektiği karar derleme zamanında verilir ve bu karar == (dize, dize) olarak görünür. bu bana Content'in dizeye örtük bir dönüşüm sağladığını gösterir.

@BlueMonkMN'nin daha önceki bir cevabının başka bir boyutu daha var. Ek boyut, @ Drahcir'in başlık sorusunun belirtildiği gibi cevabının , değere nasıl ulaştığımıza da bağlı olmasıdır string. Örneklemek gerekirse:

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

Çıktı:

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

Cevaba bir puan daha eklemek.

.EqualsTo() yöntemi, kültüre ve büyük / küçük harfe duyarlı olmanızı sağlar.

==C # içindeki simge iki farklı eşitlik denetimi operatörü için kullanılır. Derleyici bu simgeyle karşılaştığında, karşılaştırılan türlerden birinin, karşılaştırılan belirli kombinasyon türleri (*) veya her iki türün dönüştürülebileceği türlerin bir kombinasyonu için eşitlik-operatör aşırı yükü uygulayıp uygulamadığını kontrol eder. Derleyici böyle bir aşırı yük bulursa kullanır. Aksi takdirde, her iki tür de referans türüyse ve ilgisiz sınıflar değilse (bir arabirim olabilir veya ilgili sınıflar olabilir), derleyici ==bir referans karşılaştırma operatörü olarak kabul edilir. Her iki koşul da geçerli değilse derleme başarısız olur.

Diğer bazı dillerin iki eşitlik denetimi operatörü için ayrı jetonlar kullandığını unutmayın. Örneğin, VB.NET'te, =jeton ifadeler içinde yalnızca yüklenebilir eşitlik denetimi operatörü Isiçin kullanılır ve bir referans testi veya null testi operatörü olarak kullanılır. =Eşitlik denetimi operatörünü geçersiz kılmayan bir türdeki bir kullanım , Isreferans eşitliğini veya geçersizliğini sınamak dışında herhangi bir amaç için kullanmaya çalışacağı gibi başarısız olur .

(*) Tipler genellikle kendileriyle karşılaştırma için sadece aşırı yük eşitliği, ancak tiplerin diğer belirli türlerle karşılaştırma için aşırı yük operatörüne aşırı yüklenmesi yararlı olabilir; örneğin, intkarşılaştırma için bir eşitlik işleçleri tanımlayabilirdi (ve IMHO'nun yapması gerekirdi, ama floattanımamamıştı), böylece 16777217 kendisini 16777216f'ye eşit olarak bildirmezdi. Olduğu gibi böyle bir operatör tanımlanmış olduğundan, C # teşvik edecektir intiçin floateşitlik-çek operatörü görmeden 16777216f bunu yuvarlama; bu operatör daha sonra iki eşit kayan noktalı sayı görür ve gerçekleşen yuvarlamadan habersiz olarak bunları eşit olarak bildirir.

Gerçekten harika cevaplar ve örnekler!

Sadece ikisi arasındaki temel farkı eklemek istiyorum,

Gibi operatörler ==polimorfik değildir Equals,

Bu kavram göz önünde bulundurularak, herhangi bir örnek üzerinde çalışırsanız (sol el ve sağ el referans türüne bakarak ve türün gerçekten == operatör aşırı yüklendiğini ve Eşittir geçersiz kılındığını kontrol edip bilerek) doğru cevabı alacağınızdan emin olabilirsiniz. .

Herhangi bir nesne oluşturduğumuzda, nesnenin biri içerik, diğeri ise o içeriğe referans yapan iki bölüm vardır. ==hem içeriği hem de referansı karşılaştırır; equals()sadece içeriği karşılaştırır

http://www.codeproject.com/Articles/584128/What-is-the-difference-between-equalsequals-and-Eq

==

== operatörü herhangi bir türdeki iki değişkeni karşılaştırmak için kullanılabilir ve sadece bitleri karşılaştırır .

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

Not: int'in sol tarafında daha fazla sıfır var, ancak burada bunu umursamıyoruz.

int a (00000011) == bayt b (00000011)

== operatörünün yalnızca değişken içindeki bitlerin modeline önem verdiğini unutmayın.

== İki başvuru (ilkeller) öbek üzerinde aynı nesneyi gösteriyorsa kullanın.

Değişken bir referans veya ilkel olsa da kurallar aynıdır.

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 doğru a == b yanlış

bit örüntüsü a ve c için aynıdır, bu nedenle == kullanarak eşittirler.

Eşit():

İki farklı nesnenin eşit olup olmadığını görmek için equals () yöntemini kullanın .

Her ikisi de "Jane" deki karakterleri temsil eden iki farklı String nesnesi gibi

Eşit ve == arasındaki tek fark nesne türü karşılaştırmasındadır. referans türleri ve değer türleri gibi diğer durumlarda, neredeyse aynıdırlar (her ikisi de bit-bilge eşitliği veya her ikisi de referans eşitliğidir).

object: Eşittir: bit-bilge eşitliği ==: referans eşitliği

string: (eşittir ve == dize için aynıdır, ancak dizeden biri nesneye değiştirilirse karşılaştırma sonucu farklı olur) Eşittir: bit-wise eşitliği ==: bit-wise eşitliği

Daha fazla açıklama için buraya bakın .