C # ¿Qué hace el operador == en detalle?

Question

en c #, ¿qué sucede exactamente en segundo plano cuando hace una comparación con " == " operador en dos objetos? ¿solo compara las direcciones? o es algo como Equals () o CompareTo ()?

PD: ¿qué pasa con el " == " operador en java? ¿Se comporta igual?

Answer 1

Hasta donde yo sé:

• compara los tipos de valor por valor (igualdad)
• compara los tipos de referencia por referencia (identidad)
• excepto si el operador == está sobrecargado, entonces lo llama.

Equals se implementa en el objeto y también se puede anular. La implementación predeterminada en Object realiza una comparación de referencia para los tipos de referencia. Entonces, por defecto, Equals y == hacen lo mismo.

Creo que en Java no se puede sobrecargar el operador ==. Pero mi conocimiento de Java está bastante desactualizado.

Editar: Tenga en cuenta que el operador == es un método estático. Está vinculado en tiempo de compilación, basado en los tipos de sus variables o campos. Equals es un método virtual que se encuentra en tiempo de ejecución, basado en tipos de tiempo de ejecución reales.

Answer 2

Como una extensión de La excelente respuesta de Stefan - otra excepción es si los operandos involucran Nullable<T> - en cuyo caso " levantado " los operadores aplican (14.2.7 en ECMA 334v4):

  

Para los operadores de igualdad   ==! =

     

existe una forma elevada de un operador si los tipos de operando son ambos   tipos de valores no anulables y si el   El tipo de resultado es bool. La forma levantada   se construye agregando un solo?   modificador para cada tipo de operando. los   operador levantado considera dos nulos   valores iguales y un valor nulo desigual   a cualquier valor no nulo. Si ambos   los operandos no son nulos, los elevados   operador desenvuelve los operandos y   aplica el operador subyacente a   producir el resultado bool.

Lo que eso significa es: porque hay un operador de igualdad entre (digamos):

int i = ..., j = ...;
bool eq = i == j;

Por lo tanto, hay un operador implícito de la forma (aunque se hace de manera diferente):

int? i = ..., j = ...;
bool eq;
if(i.HasValue) {
    if(j.HasValue) { // both have values; compare
       eq = i.GetValueOrDefault() == j.GetValueOrDefault();
    } else { // one null; always false
       eq = false;
    }
} else { // true if both null, else false
    eq = !j.HasValue;
}

Answer 3

Desde MSDN :

  

Para los tipos de valores predefinidos, el   el operador de igualdad (==) devuelve verdadero si   los valores de sus operandos son iguales,   falso de lo contrario. Para tipos de referencia   que no sea cadena, == devuelve verdadero si   sus dos operandos se refieren al mismo   objeto. Para el tipo de cadena, ==   compara los valores de las cadenas.

Answer 4

No ... el operador == no siempre se comporta igual en Java y en C #.

Por ejemplo con cadenas; Java == compara las referencias de los objetos de cadena ... (si usa tipos primitve, == en java compara los valores). Por eso

// returns FALSE in JAVA
(new String("test") == "test") 

no devolverá verdadero en java ...

En C # en contraste, el operador == se comporta de manera diferente en las cadenas. Por ejemplo, devolverá verdadero en el siguiente caso:

// returns TRUE in C#
(new String("test".ToCharArray()) == "test") 

Answer 5

Lo que hace depende del contexto.

http://en.csharp-online.net/ECMA -334: _14.9_Relational_and_type-testing_operators

Answer 6

El comportamiento del operador == depende de cómo se declaró la variable a la que lo está aplicando (no de la clase del objeto, agregaré un ejemplo).

Para los tipos de valor, comparará sus valores.

Para los tipos de referencia a == b devuelve true si a es el mismo objeto que b, a menos que el operador == esté sobrecargado. No anulado como otros dijeron, no puede anular operadores en c # porque no son virtuales.

            objeto obj_a, obj_b;             string str_a, str_b;

        str_a = "ABC";
        str_b = new string("ABC".ToCharArray());
        obj_a = str_a;
        obj_b = str_b;

        Console.WriteLine("str_a == str_b = {0}", str_a == str_b); // in string == operator is overloaded
        Console.WriteLine("str_a.Equals(str_b) = {0}", str_a.Equals(str_b)); // string overrides Object.Euqals
        Console.WriteLine("obj_a == obj_b = {0}", obj_a == obj_b); // in object == operator is not overloaded
        Console.WriteLine("obj_a.Equals(obj_b) = {0}", obj_a.Equals(obj_b)); // Object.Equesl is virtual and overridden method from string will be executed.
        Console.ReadKey();

La salida de ese programa es

str_a == str_b = True
str_a.Equals(str_b) = True
obj_a == obj_b = False
obj_a.Equals(obj_b) = True