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

Question

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

Вот код:

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

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

Любая причина, почему это происходит?

Answer 1

Когда == используется для выражения типа object, оно будет разрешено до System.Object.ReferenceEquals.

Equals - это всего лишь метод virtual и ведет себя как таковой, поэтому будет использоваться переопределенная версия (которая для string типов сравнивает содержимое).

Answer 2

При сравнении ссылки объекта на строку (даже если ссылка на объект ссылается на строку), особое поведение оператора ==, относящегося к классу строк, игнорируется.

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

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 

Answer 3

== и .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

Answer 4

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

Answer 5

Я бы добавил, что если вы нанесете свой объект на строку, то он будет работать правильно. Вот почему компилятор даст вам предупреждение: «Возможное непреднамеренное сравнение ссылок: чтобы получить сравнение значений, введите левую сторону, чтобы набрать« строка ».

Answer 6

Добавление еще одного пункта в ответ.

.EqualsTo() метод дает вам возможность сравнить с культурой и чувствительностью к регистру.

Answer 7

== Оператор 1. Если операнды Value Types и их значения равны, то возвращает истину еще ложь. 2. Если операнды Reference Types, за исключением строки, и оба относятся к одному и тому же объекту, он возвращает true else false. 3. Если операнды являются строковыми типами и их значения равны, он возвращает true else false.

.equals 1. Если операнды ссылочные типы, он выполняет Reference Equality, то есть если оба относятся к тому же объекту, он возвращает истину еще ложь. 2. Если Операнды являются типами значений, то в отличие от оператора == он сначала проверяет их тип, и если их типы одинаковы, он выполняет == operator else, он возвращает false.

Answer 8

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

> 2 == 2.0 
True 

> 2.Equals(2.0) 
False 

И для струнных

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

> x.Equals(null) 
NullReferenceException 

В обоих случаях, == ведет себя с большей пользой, чем .Equals

Answer 9

== маркер в C# используется для двух разных операторов равенства-проверки. Когда компилятор встречает этот токен, он проверяет, осуществил ли какой-либо из сравниваемых типов перегрузку оператора равенства или для сравнения отдельных типов комбинации (*), или для комбинации типов, к которым могут быть преобразованы оба типа. Если компилятор найдет такую ​​перегрузку, он будет использовать его. В противном случае, если оба типа являются ссылочными типами, и они не являются несвязанными классами (либо они могут быть интерфейсом, либо могут быть связанными классами), компилятор будет рассматривать == в качестве оператора сравнения ссылок. Если ни одно условие не применяется, компиляция завершится неудачей.

Обратите внимание, что на некоторых других языках используются отдельные токены для двух операторов проверки равенства. В VB.NET, например, токен = используется в выражениях исключительно для перегружаемого оператора проверки равенства, а Is используется в качестве эталонного теста или оператора нулевого теста. А использовать = по типу, который не переопределяет оператора проверки равенства, не удастся, так как будет пытаться использовать Is для любых целей, кроме проверки равенства ссылок или недействительности.

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

Answer 10

Когда мы создаем какой-либо объект, в объекте есть две части, одна из которых является контентом, а другая - ссылкой на этот контент. == сравнивает как контент, так и ссылку; equals() сравнивает только содержимое

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

Answer 11

==

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

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

Примечание: в левой части окна больше нулей, но здесь нас это не волнует.

Int А (00000011) == байт б (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 == с является истинным A == B является ложным

битовая комбинация являются одинаковыми для а и с, так что они равны, используя ==.

Равные():

Используйте метод равные(), чтобы увидеть если два различных объект равен.

Такие, как два разных объекта Строковые, что оба представляют символы в «Джейн»

Answer 12

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

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

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

См. here для получения более подробного объяснения.

Answer 13

Существует еще одно измерение более раннего ответа от @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 

Answer 14

Действительно большие ответы и примеры!

Я просто хотел бы добавить фундаментальное различие между этими двумя,

Операторы, такие как == не полиморфные, в то время как Equals является

С этой концепцией в виду, что если вы работаете в любом примере (глядя на левый и правый ссылочный тип и проверяя/зная, действительно ли тип перегружен оператором ==, а Equals переопределены), вы обязательно получите правильный ответ.

Answer 15

Насколько я понимаю, ответ прост:

1. == сравнивает ссылки на объекты.
2. .Equals сравнивает содержание объектов.
3. String datatypes всегда действуют как сравнение контента.

Надеюсь, я прав, и это ответ на ваш вопрос.

Answer 16

Поскольку статическая версия метода .Equal не упоминалась до сих пор, я хотел бы добавить это здесь, чтобы суммировать и сравнить 3 варианта.

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

где MyString это переменная, которая приходит откуда-то в коде.

Справочная информация и summerize:

В 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.