Diferença de C # entre == e Equals ()

Eu tenho uma condição em um aplicativo silverlight que compara duas strings, por algum motivo, quando eu o uso ==, retorna false enquanto .Equals()retorna true .

Aqui está o código:

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

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

Alguma razão para isso estar acontecendo?

Quando ==é usado em uma expressão do tipo object, será resolvido como System.Object.ReferenceEquals.

Equalsé apenas um virtualmétodo e se comporta como tal; portanto, a versão substituída será usada (que, para o stringtipo, compara o conteúdo).

Ao comparar uma referência de objeto a uma sequência de caracteres (mesmo que a referência de objeto se refira a uma sequência de caracteres), o comportamento especial do ==operador específico da classe de sequência é ignorado.

Normalmente (quando não estiver lidando com seqüências de caracteres, isto é), Equalscompara valores , enquanto ==compara referências de objetos . Se dois objetos que você está comparando estão se referindo à mesma instância exata de um objeto, ambos retornam true, mas se um tiver o mesmo conteúdo e vier de uma fonte diferente (é uma instância separada com os mesmos dados), apenas Igual será retornar verdadeiro. No entanto, como observado nos comentários, string é um caso especial, porque substitui o ==operador, de modo que, ao lidar exclusivamente com referências de string (e não referências a objetos), apenas os valores são comparados, mesmo que sejam instâncias separadas. O código a seguir ilustra as diferenças sutis nos comportamentos:

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

A saída é:

True True True
False True True
False False True

==e .Equalsambos dependem do comportamento definido no tipo real e no tipo real no site da chamada. Ambos são apenas métodos / operadores que podem ser substituídos em qualquer tipo e com qualquer comportamento que o autor desejar. Na minha experiência, acho que é comum as pessoas implementarem .Equalsem um objeto, mas negligenciam a implementação do operador ==. Isso significa que .Equalsrealmente medirá a igualdade dos valores, enquanto ==medirá se eles são ou não a mesma referência.

Quando estou trabalhando com um novo tipo cuja definição está em fluxo ou escrevendo algoritmos genéricos, acho que a melhor prática é a seguinte

• Se eu quiser comparar referências em C #, uso Object.ReferenceEqualsdiretamente (não é necessário no caso genérico)
• Se eu quiser comparar valores eu uso EqualityComparer<T>.Default

Em alguns casos, quando sinto que o uso de ==é ambíguo, explicitamente utilizarei Object.Referenceiguais no código para remover a ambiguidade.

Eric Lippert publicou recentemente um post no blog sobre o motivo de haver dois métodos de igualdade no CLR. Vale a pena ler

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

== Operador

1. Se os operandos forem Tipos de Valor e seus valores forem iguais, ele retornará true ou false.
2. Se operandos são tipos de referência, com exceção da cadeia de caracteres e ambos se referem à mesma instância (mesmo objeto), ele retorna true else false.
3. Se operandos forem do tipo string e seus valores forem iguais, retornará true else false.

.É igual a

1. Se os operandos são Tipos de Referência , eles executam Igualdade de Referência, ou seja, se ambos se referem à mesma instância (mesmo objeto), retornam true ou false.
2. Se os operandos são tipos de valor , ao contrário do operador ==, ele verifica primeiro o tipo e, se os tipos são iguais, executa o operador ==, caso contrário, retorna false.

Em primeiro lugar, não é uma diferença. Para números

> 2 == 2.0
True

> 2.Equals(2.0)
False

E para cordas

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

> x.Equals(null)
NullReferenceException

Nos dois casos, ==comporta-se de maneira mais útil do que.Equals

Tanto quanto eu entendo, a resposta é simples:

1. == compara referências de objetos.
2. .Equals compara o conteúdo do objeto.
3. String tipos de dados sempre agem como comparação de conteúdo.

Espero estar correto e que tenha respondido sua pergunta.

Eu acrescentaria que, se você converter seu objeto em uma string, ele funcionará corretamente. É por isso que o compilador emitirá um aviso dizendo:

Possível comparação de referência não intencional; para obter uma comparação de valores, gire o lado esquerdo para digitar 'string'

Como a versão estática do .Equalmétodo não foi mencionada até agora, gostaria de adicioná-lo aqui para resumir e comparar as três variações.

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

onde MyStringé uma variável que vem de outro lugar no código.

Informações de plano de fundo e para o verão:

Em Java, usar ==para comparar seqüências de caracteres não deve ser usado. Menciono isso no caso de você precisar usar os dois idiomas e também informar que o uso de== também pode ser substituído por algo melhor em C #.

No C #, não há diferença prática para comparar seqüências de caracteres usando o Método 1 ou 2, desde que ambas sejam do tipo seqüência de caracteres. No entanto, se um é nulo, outro de outro tipo (como um número inteiro) ou um objeto que possui uma referência diferente, como mostra a pergunta inicial, você pode experimentar que comparar o conteúdo por igualdade pode não retornar o que você espera.

Solução sugerida:

Como o uso ==não é exatamente o mesmo que o da .Equalscomparação, você pode usar o método estático String.Equals . Dessa forma, se os dois lados não forem do mesmo tipo, você ainda comparará o conteúdo e se um for nulo, evitará a exceção.

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

É um pouco mais para escrever, mas na minha opinião, mais seguro de usar.

Aqui estão algumas informações copiadas da Microsoft:

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

Parâmetros

a Corda

A primeira string a comparar, ou null.

b Corda

A segunda string para comparar, ou null.

Devoluções Boolean

truese o valor de afor o mesmo que o valor de b; caso contrário false,. Se ambos ae bsão null, o método retorna true.

Apenas como uma adição às respostas já boas: Esse comportamento NÃO se limita a Strings ou compara diferentes tipos de número. Mesmo se os dois elementos forem do tipo objeto do mesmo tipo subjacente. "==" não funcionará.

A captura de tela a seguir mostra os resultados da comparação de dois objetos {int} - valores

Estou um pouco confuso aqui. Se o tipo de conteúdo do tempo de execução for do tipo string, ambos == e Equals deverão retornar true. No entanto, como esse não parece ser o caso, o tipo de conteúdo em tempo de execução não é uma string e chamar Equals está fazendo uma igualdade referencial e isso explica por que Equals ("Energy Attack") falha. No entanto, no segundo caso, a decisão sobre qual operador == estático sobrecarregado deve ser chamado é tomada em tempo de compilação e essa decisão parece ser == (string, string). isso sugere que o conteúdo fornece uma conversão implícita em string.

Há uma outra dimensão na resposta anterior de @BlueMonkMN. A dimensão adicional é que a resposta à pergunta do título do @ Drahcir, como é afirmada, também depende de como chegamos ao stringvalor. 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));

A saída é:

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

Adicionando mais um ponto à resposta.

.EqualsTo() O método fornece provisão para comparar com a cultura e diferencia maiúsculas de minúsculas.

O ==token no C # é usado para dois operadores diferentes de verificação de igualdade. Quando o compilador encontra esse token, ele verifica se um dos tipos comparados implementou uma sobrecarga de operador de igualdade para os tipos de combinação específicos que estão sendo comparados (*) ou para uma combinação de tipos nos quais os dois tipos podem ser convertidos. Se o compilador encontrar uma sobrecarga, ele a utilizará. Caso contrário, se os dois tipos são de referência e não são classes não relacionadas (podem ser uma interface ou podem ser classes relacionadas), o compilador considerará== um operador de comparação de referência. Se nenhuma das condições se aplicar, a compilação falhará.

Observe que alguns outros idiomas usam tokens separados para os dois operadores de verificação de igualdade. No VB.NET, por exemplo, o =token é usado em expressões exclusivamente para o operador de verificação de igualdade sobrecarregável e Isé usado como operador de teste de referência ou teste nulo. Um uso =em um tipo que não substitui o operador de verificação de igualdade falhará, assim como a tentativa de usarIs para qualquer outro propósito que não seja testar a igualdade ou a nulidade de referência.

(*) Os tipos geralmente sobrecarregam a igualdade apenas para comparação com eles mesmos, mas pode ser útil para os tipos sobrecarregar o operador de igualdade para comparação com outros tipos específicos; por exemplo, intpoderia ter (e o IMHO deveria ter, mas não definiu) operadores de igualdade para comparação com float, para que 16777217 não se reportasse igual a 16777216f. Como é, como esse operador não está definido, o C # promoverá o intto float, arredondando-o para 16777216f antes que o operador de verificação de igualdade o veja; esse operador então vê dois números iguais de ponto flutuante e os informa como iguais, sem saber do arredondamento ocorrido.

Respostas e exemplos realmente ótimos!

Gostaria apenas de acrescentar a diferença fundamental entre os dois,

Operadores como ==não polimórficos, enquanto Equalsé

Com esse conceito em mente, se você elaborar algum exemplo (olhando para o tipo de referência à esquerda e à direita e verificando / sabendo se o tipo realmente tem == operador sobrecarregado e igual a superação), você certamente encontrará a resposta certa .

Quando criamos qualquer objeto, existem duas partes no objeto, uma é o conteúdo e a outra é a referência a esse conteúdo. ==compara conteúdo e referência; equals()compara apenas o conteúdo

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

==

O operador == pode ser usado para comparar duas variáveis ​​de qualquer tipo e simplesmente compara os bits .

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

Nota: existem mais zeros no lado esquerdo do int, mas não nos importamos com isso aqui.

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

Lembre-se de que o operador se preocupa apenas com o padrão dos bits na variável.

Use == Se duas referências (primitivas) se referirem ao mesmo objeto no heap.

As regras são as mesmas, independentemente de a variável ser uma referência ou 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 é verdadeiro a == b é falso

o padrão de bits é o mesmo para a e c, portanto são iguais usando ==.

Igual():

Use o método equals () para ver se dois objetos diferentes são iguais .

Como dois objetos String diferentes que representam os caracteres em "Jane"

A única diferença entre Igual e == está na comparação do tipo de objeto. em outros casos, como tipos de referência e tipos de valor, eles são quase os mesmos (ambos são igualdade de bits ou ambos são igualdade de referência).

objeto: Equals: igualdade bit a bit ==: igualdade de referência

string: (iguais e == são iguais para string, mas se uma das string for alterada para objeto, o resultado da comparação será diferente) Igual a: igualdade de bits ==: igualdade de bits

Veja aqui para mais explicações.