Por que (objeto) 0 == (objeto) 0 é diferente de ((objeto) 0) .Equals ((objeto) 0)?

Por que as seguintes expressões são diferentes?

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

Na verdade, eu posso entender totalmente [1] porque provavelmente o runtime do .NET vai para boxo inteiro e começa a comparar as referências. Mas por que [2] é diferente?

O motivo pelo qual as chamadas se comportam de maneira diferente é que elas se vinculam a métodos muito diferentes.

O ==caso será vinculado ao operador de igualdade de referência estática. Existem 2 intvalores em caixas independentes criados, portanto, eles não são a mesma referência.

No segundo caso, você vincula ao método de instância Object.Equals. Este é um método virtual que irá filtrar Int32.Equalse verificar se há um inteiro em caixa. Ambos os valores inteiros são 0, portanto, são iguais

Quando você converte o valor int 0(ou qualquer outro tipo de valor) para object, o valor é inserido em uma caixa . Cada elenco objectproduz uma caixa diferente (ou seja, uma instância de objeto diferente). O ==operador para o objecttipo executa uma comparação de referência, portanto, ele retorna falso, pois o lado esquerdo e o lado direito não são a mesma instância.

Por outro lado, quando você usa Equals, que é um método virtual, ele usa a implementação do tipo boxed real, ou seja Int32.Equals, que retorna true já que ambos os objetos têm o mesmo valor.

O ==operador, sendo estático, não é virtual. Ele executará o código exato que a objectclasse definir (`objeto sendo o tipo de tempo de compilação dos operandos), que fará uma comparação de referência, independentemente do tipo de tempo de execução de qualquer um dos objetos.

O Equalsmétodo é um método de instância virtual. Ele executará o código definido no tipo de tempo de execução real do (primeiro) objeto, não o código da objectclasse. Neste caso, o objeto é um int, então ele fará uma comparação de valores, pois é o que o inttipo define para seu Equalsmétodo.

O Equals()método é virtual.
Portanto, ele sempre chama a implementação concreta, mesmo quando o callite é convertido para object. intsubstitui Equals()para comparar por valor, para que você obtenha a comparação de valor.

== Usar: Object.ReferenceEquals

Object.Equals compara o valor.

O object.ReferenceEqualsmétodo compara referências. Ao alocar um objeto, você recebe uma referência que contém um valor que indica sua localização na memória, além dos dados do objeto no heap de memória.

O object.Equalsmétodo compara o conteúdo dos objetos. Ele primeiro verifica se as referências são iguais, assim como object.ReferenceEquals. Mas então ele chama métodos derivados de Equals para testar ainda mais a igualdade. Veja isso:

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

O operador C # usa o token ==para representar dois operadores diferentes: um operador de comparação estaticamente sobrecarregável e um operador de comparação de referência não sobrecarregável. Ao encontrar o ==token, ele primeiro verifica se existe alguma sobrecarga de teste de igualdade que seja aplicável aos tipos de operando. Nesse caso, ele invocará essa sobrecarga. Caso contrário, ele verificará se os tipos são aplicáveis ​​ao operador de comparação de referência. Nesse caso, ele usará esse operador. Se nenhum dos operadores for aplicável aos tipos de operando, a compilação falhará.

O código (Object)0não se limita a upcast um Int32para Object: Int32, como todos os tipos de valor, na verdade representa dois tipos, um dos quais descreve valores e locais de armazenamento (como a de zero literal), mas não deriva de qualquer coisa, e um dos quais descreve heap objetos e deriva Object; como apenas o último tipo pode ser atualizado Object, o compilador deve criar um novo objeto de heap desse último tipo. Cada chamada de (Object)0cria um novo objeto heap, de modo que os dois operandos to ==são objetos diferentes, cada um dos quais, independentemente, encapsula o Int32valor 0.

A classe Objectnão possui sobrecargas utilizáveis ​​definidas para o operador igual. Conseqüentemente, o compilador não poderá usar o operador de teste de igualdade sobrecarregado e voltará a usar o teste de igualdade de referência. Como os dois operandos se ==referem a objetos distintos, ele relatará false. A segunda comparação é bem-sucedida porque pergunta a uma instância do objeto heap Int32se ela é igual à outra. Como essa instância sabe o que significa ser igual a outra instância distinta, ela pode responder true.

Ambas as verificações são diferentes. O primeiro verifica a identidade , o segundo verifica a igualdade . Em geral, dois termos são idênticos, se eles se referem ao mesmo objeto. Isso implica que eles são iguais. Dois termos são iguais, se seus valores forem iguais.

Em termos de programação, a identidade geralmente é confundida por igualdade de referência. Se o ponteiro para ambos os termos for igual (!), O objeto para o qual eles estão apontando é exatamente o mesmo. No entanto, se os ponteiros forem diferentes, o valor dos objetos para os quais eles estão apontando ainda pode ser igual. Em C #, a identidade pode ser verificada usando o Object.ReferenceEqualsmembro estático , enquanto a igualdade é verificada usando o Object.Equalsmembro não estático . Como você está convertendo dois inteiros para objetos (o que é chamado de "boxing", aliás), o operador ==de objectrealiza a primeira verificação, que por padrão é mapeada Object.ReferenceEqualse verifica a identidade. Se você chamar explicitamente o não-estático Equals-member, o despacho dinâmico resultará em uma chamada para Int32.Equals, que verifica a igualdade.

Ambos os conceitos são semelhantes, mas não iguais. Eles podem parecer confusos no início, mas a pequena diferença é muito importante! Imagine duas pessoas, nomeadamente "Alice" e "Bob". Os dois estão morando em uma casa amarela. Partindo do pressuposto de que Alice e Bob estão morando em um bairro onde as casas têm apenas cores diferentes, os dois poderiam morar em casas amarelas diferentes. Se você comparar as duas casas, você reconhecerá que são absolutamente iguais, porque ambas são amarelas! No entanto, eles não estão compartilhando a mesma casa e, portanto, suas casas são iguais , mas não idênticas . A identidade implicaria que eles estão morando na mesma casa.

Nota : alguns idiomas estão definindo o ===operador para verificar a identidade.