C # разница между == и Equals ()

У меня есть условие в приложении silverlight, которое сравнивает 2 строки, по какой-то причине, когда я использую ==его, возвращает false, а .Equals()возвращает true .

Вот код:

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сравнивает значения , а ==сравнивает ссылки на объекты . Если два объекта, которые вы сравниваете, ссылаются на один и тот же точный экземпляр объекта, то оба будут возвращать true, но если один имеет одинаковое содержимое и поступил из другого источника (это отдельный экземпляр с одинаковыми данными), только 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в коде equals для устранения неоднозначности.

Эрик Липперт недавно сделал сообщение в блоге на тему, почему в CLR есть 2 метода равенства. Стоит прочитать

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

== Оператор

1. Если операнды являются типами значений и их значения равны, он возвращает true, иначе false.
2. Если операнды являются ссылочными типами, за исключением строки, и оба ссылаются на один и тот же экземпляр (один и тот же объект), он возвращает true, иначе false.
3. Если операнды имеют строковый тип и их значения равны, он возвращает true, иначе false.

.equals

1. Если операнды являются ссылочными типами , он выполняет эталонное равенство, то есть если оба ссылаются на один и тот же экземпляр (один и тот же объект), он возвращает true, иначе false.
2. Если операнды являются типами значений, то в отличие от оператора == он сначала проверяет их тип, а если их типы совпадают, он выполняет оператор ==, в противном случае он возвращает false.

Во - первых, это разница. Для номеров

> 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, если оба имеют тип string. Однако, если один имеет значение null, другой имеет другой тип (например, целое число) или один представляет объект, имеющий другую ссылку, то, как показывает первоначальный вопрос, вы можете столкнуться с тем, что сравнение содержимого на равенство может не дать того, что вы ожидаете.

Предлагаемое решение:

Поскольку использование ==- это не то же самое, что использование .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.

Просто как дополнение к и без того хорошим ответам: это поведение не ограничивается строками или сравнением различных числовых типов. Даже если оба элемента имеют тип объекта одного и того же базового типа. "==" не сработает.

На следующем снимке экрана показаны результаты сравнения двух значений объекта {int}.

Я немного смущен здесь. Если тип времени выполнения Content имеет тип string, то оба == и Equals должны возвращать true. Однако, поскольку это не так, то тип контента во время выполнения не является строкой, и вызов Equals для него делает ссылочное равенство, и это объясняет, почему Equals («энергетическая атака») завершается неудачно. Однако во втором случае решение о том, какой перегруженный == статический оператор должен быть вызван, принимается во время компиляции, и это решение выглядит как == (строка, строка). это говорит мне о том, что Content обеспечивает неявное преобразование в строку.

Есть еще одно измерение в более раннем ответе @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используется в качестве оператора reference-test или null-test. Использовать =для типа, который не переопределяет оператор проверки на равенство, не удастся, так же как и для попытки использовать его Isдля любой цели, кроме проверки ссылочного равенства или недействительности.

(*) Типы обычно только перегружают равенство для сравнения с самим собой, но может быть полезно, чтобы типы перегружали оператор равенства для сравнения с другими конкретными типами; например, intмог бы (и ИМХО должен был, но не сделал) определить операторы равенства для сравнения с floatтаким образом, чтобы 16777217 не сообщал о себе равным 16777216f. Как таковой, так как такой оператор не определен, C # будет повышать intto 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, которые оба представляют символы в «Джейн»

Единственная разница между Equal и == заключается в сравнении типов объектов. в других случаях, таких как ссылочные типы и типы значений, они почти одинаковы (либо оба имеют битовое равенство, либо оба являются ссылочным равенством).

объект: равно: побитовое равенство ==: ссылочное равенство

строка: (равно и == одинаковы для строки, но если одна из строк изменена на объект, результат сравнения будет другим) Равно: побитовое равенство ==: побитовое равенство

Смотрите здесь для более подробного объяснения.