Різниця C # == і дорівнює ()

У мене є умова програми Silverlight, яка порівнює 2 рядки, чомусь коли я використовую, ==вона повертає помилку, а .Equals()повертає істину .

Ось код:

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

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

Будь-яка причина, чому це відбувається?

Якщо ==використовується для виразу типу object, воно вирішиться для System.Object.ReferenceEquals.

Equalsє лише virtualметодом і поводиться як такий, тому буде використана переосмислена версія (яка для stringтипу порівнює вміст).

При порівнянні посилання на об'єкт на рядок (навіть якщо посилання на об'єкт посилається на рядок), особлива поведінка ==оператора, специфічного для класу рядків, ігнорується.

Зазвичай (якщо справа не стосується рядків, тобто) Equalsпорівнює значення , а ==порівнює об'єктні посилання . Якщо два об'єкти, які ви порівнюєте, посилаються на один і той самий точний екземпляр об'єкта, то обидва повернуть істину, але якщо один має однаковий вміст і прийшов з іншого джерела (це окремий екземпляр з тими ж даними), тільки рівний повернути правду. Однак, як зазначається в коментарях, рядок є особливим випадком, оскільки він переосмислює ==оператора, так що при чистому посиланні на рядки (а не посилання на об'єкти), порівнюються лише значення, навіть якщо це окремі екземпляри. Наступний код ілюструє тонкі відмінності в поведінці:

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

Вихід:

True True True
False True True
False False True

==і .Equalsзалежать від поведінки, визначеної у фактичному типі та фактичному типі на сайті виклику. Обидва - це лише методи / оператори, які можуть бути переохолоджені на будь-який тип та мати будь-яку поведінку, якої бажає автор. З мого досвіду, я вважаю, що люди звичайно реалізують .Equalsна об'єкті, але нехтують оператором реалізації ==. Це означає, що .Equalsнасправді буде вимірювати рівність значень, тоді як ==буде вимірювати, чи є вони однаковою базою.

Коли я працюю з новим типом, визначення якого знаходиться в потоці або пише загальні алгоритми, я вважаю, що найкраща практика полягає в наступному

• Якщо я хочу порівняти посилання на C #, я використовую Object.ReferenceEqualsбезпосередньо (не потрібен у загальному випадку)
• Якщо я хочу порівняти використовувані значення EqualityComparer<T>.Default

У деяких випадках, коли я вважаю, що використання цього ==є неоднозначним, я буду явно використовуватиObject.Reference в коді рівності, щоб усунути неоднозначність.

Нещодавно Ерік Ліпперт зробив публікацію в блозі на тему, чому в CLR є два способи рівності. Варто прочитати

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

== Оператор

1. Якщо операнди - це типи значень та їх значення рівні, вони повертають істинне інше хибне.
2. Якщо операнди є типовими типами, за винятком рядка, і обидва посилаються на один і той же екземпляр (той самий об'єкт), він повертає істинне інше хибне.
3. Якщо операнди мають рядковий тип і їх значення рівні, він повертає істинне інше хибне.

.Equals

1. Якщо операнди є еталонними типами , він виконує еталонне рівність , тобто якщо обидва посилаються на один і той же екземпляр (один і той же об'єкт), він повертає істинне інше хибне.
2. Якщо операнди - це типи значень, то на відміну від оператора ==, він спочатку перевіряє їх тип, а якщо їх типи однакові, він виконує == оператор інше, він повертає помилкове значення.

По-перше, є різниця. Для чисел

> 2 == 2.0
True

> 2.Equals(2.0)
False

А для струн

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

> x.Equals(null)
NullReferenceException

В обох випадках ==веде себе більш корисно, ніж.Equals

Наскільки я розумію, відповідь проста:

1. == порівнює посилання на об'єкти.
2. .Equals порівнює об’єктний вміст.
3. String типи даних завжди діють як порівняння контенту.

Я сподіваюся, що я правильно і що він відповів на ваше запитання.

Я додам, що якщо ви кинете об'єкт на рядок, він буде працювати правильно. Ось чому компілятор видасть вам попередження:

Можливе ненавмисне порівняння посилань; щоб порівняти значення, наведіть ліву частину набрати "рядок"

Оскільки статична версія .Equalметоду досі не згадувалася, я хотів би додати це сюди, щоб узагальнити та порівняти 3 варіації.

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

де MyStringє змінна, яка надходить десь у коді.

Довідкова інформація та літо:

У Java, що використовує ==для порівняння рядки, не слід використовувати. Я згадую про це, якщо вам потрібно використовувати обидві мови, а також повідомляти про це== також можна замінити чимось кращим у C #.

У C # немає практичної різниці для порівняння рядків за допомогою методу 1 або методу 2 до тих пір, поки обидва мають рядковий тип. Однак, якщо нуль, інший тип (наприклад, ціле число) або один представляє об'єкт, який має іншу посилання, то, як показує початкове запитання, ви можете відчути, що порівняння вмісту для рівності може не повернути те, що ви очікуєте

Пропоноване рішення:

Оскільки використання ==не зовсім таке, як використання .Equalsпри порівнянні речей, ви можете використовувати статичний метод String.Equals замість цього. Таким чином, якщо дві сторони не є одним типом, ви все одно будете порівнювати вміст, і якщо одна недійсна, ви уникнете винятку.

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

Трохи більше писати, але, на мій погляд, безпечніше використовувати.

Ось інформація, скопійована з Microsoft:

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

Параметри

a Рядок

Перший рядок для порівняння, або null.

b Рядок

Другий рядок для порівняння, або null.

Повертається Boolean

trueякщо значення aтаке ж, як значення b; в іншому випадку false. Якщо обидва aі bє null, метод повертається true.

Як додаток до вже хороших відповідей: така поведінка НЕ ​​обмежується рядками або порівнянням різних типів чисел. Навіть якщо обидва елементи є об'єктом типу одного і того ж базового типу. "==" не працюватиме.

На наступному скріншоті показані результати порівняння двох об'єктних значень

Я тут трохи розгублений. Якщо тип виконання вмісту має рядковий тип, то обидва == і рівне повинні повернути true. Однак, оскільки, схоже, це не так, то тип вмісту під час виконання не є рядковим, а виклик рівних на ньому робить референтну рівність, і це пояснює, чому рівне ("енергетична атака") не вдається. Однак у другому випадку рішення про те, до якого слід викликати перевантажений == статичний оператор, приймається під час компіляції, і це рішення є == (рядок, рядок). це говорить про те, що вміст забезпечує неявне перетворення в рядок.

Є ще один вимір попередньої відповіді від @BlueMonkMN. Додатковий вимір полягає в тому, що відповідь на запитання назви @ Drahcir, як це зазначено, також залежить від того, як ми дійшли до stringзначення. Проілюструвати:

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

Вихід:

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

Додавання ще однієї точки до відповіді.

.EqualsTo() метод дає вам можливість порівняти культуру та залежність від регістру.

==Маркер в C # використовується для двох різних операторів рівності-перевірки. Коли компілятор зіткнеться з цим маркером, він перевірить, чи один із типів, що порівнюються, реалізував перевантаження оператора рівності для конкретних типів комбінації, що порівнюється (*), або для комбінації типів, до яких обидва типи можуть бути перетворені. Якщо компілятор знайде таке перевантаження, він використовуватиме його. В іншому випадку, якщо обидва типи є обома еталонними типами і вони не пов'язані між собою класами (або це може бути інтерфейс, або вони можуть бути пов'язаними класами), компілятор буде розглядатись ==як оператор порівняння посилань. Якщо не застосовується жодна умова, компіляція не вдасться.

Зауважте, що деякі інші мови використовують окремі маркери для двох операторів перевірки рівності. Наприклад, у VB.NET =маркер використовується у виразах виключно для оператора перевірки рівності, який можна завантажити, і Isвикористовується як оператор еталонного тестування або нульового тестування. Використання =типу, що не переосмислює оператор перевірки рівності, не вдасться, як і спроби використанняIs для будь-якої іншої мети, крім тестування еталонної рівності чи недійсності.

(*) Типи, як правило, лише перевантажують рівність для порівняння з собою, але може бути корисним для типів перевантажувати оператор рівності для порівняння з іншими конкретними типами; наприклад, intміг (і IMHO мав би, але не) визначив операторів рівності для порівняння float, щоб 16777217 не повідомив про себе рівним 16777216f. Оскільки це не, оскільки жоден такий оператор не визначений, C # просуне intдо float, округлюючи його до 16777216f, перш ніж оператор перевірки рівності бачить його; Потім оператор бачить два рівні числа з плаваючою комою і повідомляє про них як про рівних, не знаючи про округлення, що відбулося.

Дійсно чудові відповіді та приклади!

Я просто хотів би додати принципову різницю між ними,

Такі оператори, як ==не є поліморфними, поки Equalsє

Маючи на увазі цю концепцію, якщо ви працюєте з будь-яким прикладом (дивлячись на тип посилання лівої та правої руки та перевіряючи / знаючи, чи справді тип перевантажений == оператор перевантажений і рівне, що його перекрито), ви впевнені, щоб отримати правильну відповідь .

Коли ми створюємо будь-який об’єкт, до об'єкта є дві частини, одна - це вміст, а інша - посилання на цей вміст. ==порівнює як зміст, так і посилання; equals()порівнює лише зміст

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

==

Оператор == може використовуватися для порівняння двох змінних будь-якого типу, і він просто порівнює біти .

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

Примітка: на лівій стороні int є більше нулів, але нас це не хвилює.

int a (00000011) == байт b (00000011)

Пам'ятайте, що оператор == піклується лише про візерунок бітів змінної.

Використовуйте == Якщо два посилання (примітиви) посилаються на один і той же об'єкт у купі.

Правила однакові, незалежно від того, чи є змінна референтною чи примітивною.

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 вірно a == b - помилково

візерунок бітів однаковий для a і c, тому вони рівні, використовуючи ==.

Дорівнює ():

Використовуйте метод equals (), щоб побачити, чи однакові два різні об'єкти .

Наприклад, два різних об'єкти String, які обоє представляють символів у "Джейн"

Єдина різниця між рівними та == полягає у порівнянні типів об’єктів. в інших випадках, таких як еталонні типи та типи значень, вони майже однакові (або обидва є бітовою рівністю, або обидва є еталонною рівністю).

об'єкт: Дорівнює: біт-розумна рівність ==: опорна рівність

рядок: (дорівнює і == однакові для рядка, але якщо одна з рядків змінилася на об'єкт, результат порівняння буде іншим) Дорівнює: біт-розумна рівність ==: біт-мудра рівність

Дивіться тут для отримання додаткових пояснень.