C # diferencia entre == y Equals ()

Tengo una condición en una aplicación de Silverlight que compara 2 cadenas, por alguna razón cuando la uso ==devuelve false mientras .Equals()devuelve true .

Aquí está el código:

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

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

¿Alguna razón de por qué sucede esto?

Cuando ==se usa en una expresión de tipo object, se resolverá System.Object.ReferenceEquals.

Equalses solo un virtualmétodo y se comporta como tal, por lo que se utilizará la versión anulada (que, por stringtipo, compara los contenidos).

Al comparar una referencia de objeto a una cadena (incluso si la referencia de objeto se refiere a una cadena), ==se ignora el comportamiento especial del operador específico de la clase de cadena.

Normalmente (cuando no se trata de cadenas, es decir), Equalscompara valores , mientras ==compara referencias de objetos . Si dos objetos que está comparando se refieren a la misma instancia exacta de un objeto, ambos devolverán verdadero, pero si uno tiene el mismo contenido y proviene de una fuente diferente (es una instancia separada con los mismos datos), solo Equals lo hará volver verdadero. Sin embargo, como se señaló en los comentarios, la cadena es un caso especial porque anula el ==operador, de modo que cuando se trata únicamente de referencias de cadena (y no referencias de objeto), solo se comparan los valores, incluso si son instancias separadas. El siguiente código ilustra las sutiles diferencias en los comportamientos:

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

El resultado es:

True True True
False True True
False False True

==y .Equalsambos dependen del comportamiento definido en el tipo real y el tipo real en el sitio de la llamada. Ambos son solo métodos / operadores que se pueden anular en cualquier tipo y dar cualquier comportamiento que el autor desee. En mi experiencia, encuentro que es común que las personas implementen .Equalsen un objeto pero descuidan implementar el operador ==. Esto significa que en .Equalsrealidad medirá la igualdad de los valores mientras ==medirá si son o no la misma referencia.

Cuando estoy trabajando con un nuevo tipo cuya definición está en flujo o escribiendo algoritmos genéricos, la mejor práctica es la siguiente

• Si quiero comparar referencias en C #, las uso Object.ReferenceEqualsdirectamente (no es necesario en el caso genérico)
• Si quiero comparar valores, uso EqualityComparer<T>.Default

En algunos casos, cuando siento que el uso de ==es ambiguo, usaré explícitamente Object.Referenceiguales en el código para eliminar la ambigüedad.

Eric Lippert recientemente hizo una publicación de blog sobre el tema de por qué hay 2 métodos de igualdad en el CLR. Vale la pena leer

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

== Operador

1. Si los operandos son tipos de valor y sus valores son iguales, devuelve verdadero más falso.
2. Si los operandos son tipos de referencia con excepción de una cadena y ambos se refieren a la misma instancia (mismo objeto), devuelve verdadero más falso.
3. Si los operandos son de tipo cadena y sus valores son iguales, devuelve verdadero más falso.

Igual

1. Si los operandos son Tipos de referencia , realiza Igualdad de referencia, es decir, si ambos se refieren a la misma instancia (mismo objeto), devuelve verdadero más falso.
2. Si los operandos son tipos de valor , a diferencia del operador ==, primero verifica su tipo y si sus tipos son iguales, realiza el operador ==, de lo contrario, devuelve falso.

En primer lugar, no es una diferencia. Para números

> 2 == 2.0
True

> 2.Equals(2.0)
False

Y para cuerdas

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

> x.Equals(null)
NullReferenceException

En ambos casos, se ==comporta de manera más útil que.Equals

Por lo que yo entiendo, la respuesta es simple:

1. == compara referencias de objetos.
2. .Equals compara el contenido del objeto.
3. String los tipos de datos siempre actúan como comparación de contenido.

Espero estar en lo cierto y que haya respondido a tu pregunta.

Agregaría que si arroja su objeto a una cadena, funcionará correctamente. Es por eso que el compilador le dará una advertencia que dice:

Posible comparación de referencia involuntaria; para obtener una comparación de valores, eche el lado izquierdo para escribir 'string'

Debido a que la versión estática del .Equalmétodo no se mencionó hasta ahora, me gustaría agregar esto aquí para resumir y comparar las 3 variaciones.

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

donde MyStringes una variable que viene de otra parte del código.

Información de fondo y para verano:

En Java, usar ==para comparar cadenas no debe usarse. Menciono esto en caso de que necesite usar ambos idiomas y también para hacerle saber que el uso ==también se puede reemplazar con algo mejor en C #.

En C # no hay diferencia práctica para comparar cadenas usando el Método 1 o el Método 2, siempre que ambas sean de tipo cadena. Sin embargo, si uno es nulo, uno es de otro tipo (como un número entero), o uno representa un objeto que tiene una referencia diferente, entonces, como lo muestra la pregunta inicial, puede experimentar que comparar el contenido para la igualdad no devuelva lo que tu esperas.

Solución sugerida:

Debido a que usar ==no es exactamente lo mismo que usar .Equalsal comparar cosas, puedes usar el método estático String.Equals en su lugar. De esta manera, si los dos lados no son del mismo tipo, todavía comparará el contenido y si uno es nulo, evitará la excepción.

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

Es un poco más para escribir, pero en mi opinión, es más seguro de usar.

Aquí hay información copiada de Microsoft:

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

Parámetros

a Cuerda

La primera cadena para comparar, o null.

b Cuerda

La segunda cadena para comparar, o null.

Devoluciones Boolean

truesi el valor de aes el mismo que el valor de b; de lo contrario, false. Si ambos ay bson null, el método regresa true.

Solo como una adición a las respuestas ya buenas: este comportamiento NO se limita a las cadenas o la comparación de diferentes tipos de números. Incluso si ambos elementos son de tipo objeto del mismo tipo subyacente. "==" no funcionará.

La siguiente captura de pantalla muestra los resultados de comparar dos objetos {int} - valores

Estoy un poco confundido aquí. Si el tipo de contenido de tiempo de ejecución es de tipo cadena, entonces ambos == y Equals deberían devolver verdadero. Sin embargo, dado que este no parece ser el caso, entonces el tipo de contenido de tiempo de ejecución no es una cadena y llamar a Iguales es una igualdad referencial y esto explica por qué falla Equals ("Energy Attack"). Sin embargo, en el segundo caso, la decisión sobre qué operador sobrecargado == estático debería llamarse en tiempo de compilación y esta decisión parece ser == (cadena, cadena). Esto me sugiere que el Contenido proporciona una conversión implícita a cadena.

Hay otra dimensión a una respuesta anterior de @BlueMonkMN. La dimensión adicional es que la respuesta a la pregunta del título de @ Drahcir como se dice también depende de cómo llegamos al stringvalor. Para ilustrar:

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

El resultado es:

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

Agregar un punto más a la respuesta.

.EqualsTo() El método le brinda la posibilidad de comparar con la cultura y mayúsculas y minúsculas.

El ==token en C # se usa para dos operadores diferentes de verificación de igualdad. Cuando el compilador encuentra ese token, verificará si alguno de los tipos comparados ha implementado una sobrecarga de operador de igualdad para los tipos de combinación específicos que se comparan (*) o para una combinación de tipos a los que ambos tipos se pueden convertir. Si el compilador encuentra una sobrecarga, la usará. De lo contrario, si los dos tipos son ambos tipos de referencia y no son clases no relacionadas (pueden ser una interfaz o pueden ser clases relacionadas), el compilador lo considerará ==como un operador de comparación de referencias. Si ninguna de las condiciones se aplica, la compilación fallará.

Tenga en cuenta que algunos otros idiomas usan tokens separados para los dos operadores de verificación de igualdad. En VB.NET, por ejemplo, el =token se usa dentro de expresiones únicamente para el operador de verificación de igualdad sobrecargable, y Isse usa como operador de prueba de referencia o de prueba nula. Un uso =en un tipo que no anula el operador de verificación de igualdad fallará, al igual que intentar usarlo Ispara cualquier propósito que no sea probar la igualdad o nulidad de referencia.

(*) Los tipos generalmente solo sobrecargan la igualdad para comparación con ellos mismos, pero puede ser útil para los tipos sobrecargar el operador de igualdad para la comparación con otros tipos particulares; por ejemplo, intpodría haber (y en mi humilde opinión debería haberlo definido, pero no lo hizo) un operador de igualdad para compararlo float, de modo que 16777217 no se reportaría igual a 16777216f. Tal como están las cosas, dado que dicho operador no está definido, C # promoverá el intto float, redondeándolo a 16777216f antes de que el operador de verificación de igualdad lo vea; ese operador luego ve dos números iguales de punto flotante y los informa como iguales, sin darse cuenta del redondeo que tuvo lugar.

Realmente excelentes respuestas y ejemplos!

Solo me gustaría agregar la diferencia fundamental entre los dos,

Los operadores como ==no son polimórficos, mientras que Equalsson

Con ese concepto en mente, si resuelve algún ejemplo (mirando el tipo de referencia de la mano izquierda y derecha, y verificando / sabiendo si el tipo realmente tiene == operador sobrecargado y Equals siendo anulado), seguramente obtendrá la respuesta correcta .

Cuando creamos cualquier objeto hay dos partes en el objeto, una es el contenido y la otra es referencia a ese contenido. ==compara tanto el contenido como la referencia; equals()compara solo contenido

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

==

El operador == puede usarse para comparar dos variables de cualquier tipo, y simplemente compara los bits .

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

Nota: hay más ceros en el lado izquierdo del int pero no nos importa eso aquí.

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

Recuerde que el operador == solo se preocupa por el patrón de los bits en la variable.

Use == Si dos referencias (primitivas) se refieren al mismo objeto en el montón.

Las reglas son las mismas tanto si la variable es una referencia como si es primitiva.

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 es verdadero a == b es falso

los patrones de bits son los mismos para ayc, por lo que son iguales usando ==.

Igual():

Use el método equals () para ver si dos objetos diferentes son iguales .

Como dos objetos String diferentes que representan los personajes de "Jane"

La única diferencia entre Igual y == está en la comparación del tipo de objeto. en otros casos, como los tipos de referencia y los tipos de valor, son casi iguales (ambos son igualdad de bits o ambos son igualdad de referencia).

objeto: igual: igualdad de bits ==: igualdad de referencia

cadena: (igual y == son lo mismo para la cadena, pero si una de la cadena cambia a objeto, entonces el resultado de la comparación será diferente) Igual: igualdad de bits ==: igualdad de bits

Ver aquí para más explicaciones.