¿Por qué (objeto) 0 == (objeto) 0 es diferente de ((objeto) 0) .Equals ((objeto) 0)?

¿Por qué las siguientes expresiones son diferentes?

[1]  (object)0 == (object)0 //false
[2]  ((object)0).Equals((object)0) // true

De hecho, puedo entender totalmente [1] porque probablemente el tiempo de ejecución de .NET será boxel entero y comenzará a comparar las referencias. Pero, ¿por qué [2] es diferente?

La razón por la que las llamadas se comportan de manera diferente es que se unen a métodos muy diferentes.

El ==caso se vinculará al operador de igualdad de referencia estática. Se intcrean 2 valores en recuadros independientes , por lo que no son la misma referencia.

En el segundo caso, se vincula al método de instancia Object.Equals. Este es un método virtual que filtrará y buscará Int32.Equalsun entero en caja. Ambos valores enteros son 0, por lo tanto, son iguales

Cuando lanza el valor int 0(o cualquier otro tipo de valor) a object, el valor está en un cuadro . Cada lanzamiento objectproduce una caja diferente (es decir, una instancia de objeto diferente). El ==operador del objecttipo realiza una comparación de referencia, por lo que devuelve falso, ya que el lado izquierdo y el lado derecho no son la misma instancia.

Por otro lado, cuando usa Equals, que es un método virtual, usa la implementación del tipo en caja real, es decir Int32.Equals, que devuelve verdadero ya que ambos objetos tienen el mismo valor.

El ==operador, al ser estático, no es virtual. Ejecutará el código exacto que objectdefine la clase (siendo el objeto el tipo de tiempo de compilación de los operandos), que hará una comparación de referencia, independientemente del tipo de tiempo de ejecución de cualquiera de los objetos.

El Equalsmétodo es un método de instancia virtual. Ejecutará el código definido en el tipo de tiempo de ejecución real del (primer) objeto, no el código de la objectclase. En este caso, el objeto es un int, por lo que realizará una comparación de valores, ya que eso es lo que intdefine el tipo para su Equalsmétodo.

El Equals()método es virtual.
Por lo tanto, siempre llama a la implementación concreta, incluso cuando el sitio de llamadas está dirigido a object. intanula la Equals()comparación por valor, por lo que obtiene una comparación de valor.

== Utilizar: Object.ReferenceEquals

Object.Equals compara el valor.

El object.ReferenceEqualsmétodo compara referencias. Cuando asigna un objeto, recibe una referencia que contiene un valor que indica su ubicación de memoria además de los datos del objeto en el montón de memoria.

El object.Equalsmétodo compara el contenido de los objetos. Primero verifica si las referencias son iguales, al igual que object.ReferenceEquals. Pero luego llama a los métodos Equals derivados para probar más la igualdad. Mira esto:

   System.Object a = new System.Object();
System.Object b = a;
System.Object.ReferenceEquals(a, b);  //returns true

El operador de C # usa el token ==para representar dos operadores diferentes: un operador de comparación sobrecargable estáticamente y un operador de comparación de referencia no sobrecargable. Cuando encuentra el ==token, primero verifica si existe alguna sobrecarga de prueba de igualdad que sea aplicable a los tipos de operandos. Si es así, invocará esa sobrecarga. De lo contrario, comprobará si los tipos son aplicables al operador de comparación de referencias. Si es así, utilizará ese operador. Si ningún operador es aplicable a los tipos de operandos, la compilación fallará.

El código (Object)0no se limita a convertir un Int32to Object: Int32como todos los tipos de valor, en realidad representa dos tipos, uno de los cuales describe valores y ubicaciones de almacenamiento (como el cero literal), pero no se deriva de nada, y uno de los cuales describe amontonar objetos y se deriva de Object; debido a que solo se puede convertir al último tipo Object, el compilador debe crear un nuevo objeto de montón de ese último tipo. Cada invocación de (Object)0crea un nuevo objeto de pila, por lo que los dos operandos ==son objetos diferentes, cada uno de los cuales, de forma independiente, encapsula el Int32valor 0.

La clase Objectno tiene ninguna sobrecarga utilizable definida para el operador igual. En consecuencia, el compilador no podrá utilizar el operador de prueba de igualdad sobrecargado y volverá a utilizar la prueba de igualdad de referencia. Debido a que los dos operandos se ==refieren a objetos distintos, informará false. La segunda comparación tiene éxito porque pregunta a una instancia de objeto de montón Int32si es igual a la otra. Como esa instancia sabe lo que significa ser igual a otra instancia distinta, puede responder true.

Ambos controles son diferentes. El primero comprueba la identidad , el segundo la igualdad . En general, dos términos son idénticos si se refieren al mismo objeto. Esto implica que son iguales. Dos términos son iguales, si sus valores son iguales.

En términos de programación, la identidad suele estar dividida por la igualdad de referencias. Si el puntero a ambos términos es igual (!), El objeto al que apuntan es exactamente el mismo. Sin embargo, si los punteros son diferentes, el valor de los objetos a los que apuntan puede ser igual. En C #, la identidad se puede verificar usando el Object.ReferenceEqualsmiembro estático , mientras que la igualdad se verifica usando el Object.Equalsmiembro no estático . Dado que está lanzando dos enteros a objetos (lo que se llama "boxeo", por cierto), el operador ==de objectrealiza la primera verificación, que está asignada por defecto Object.ReferenceEqualsy verifica la identidad. Si llama explícitamente al Equalsmiembro no estático , el envío dinámico da como resultado una llamada a Int32.Equals, que verifica la igualdad.

Ambos conceptos son similares, pero no iguales. Pueden parecer confusos al principio, ¡pero la pequeña diferencia es muy importante! Imagínese dos personas, a saber, "Alice" y "Bob". Ambos viven en una casa amarilla. Basado en la suposición de que Alice y Bob viven en un distrito, donde las casas solo difieren en su color, ambos podrían vivir en diferentes casas amarillas. Si comparas ambas casas, reconocerás que son absolutamente iguales, ¡porque ambas son amarillas! Sin embargo, no comparten la misma casa y, por lo tanto, sus casas son iguales , pero no idénticas . La identidad implicaría que viven en la misma casa.

Nota : algunos idiomas están definiendo al ===operador para verificar la identidad.