Compare String e Object em C #

Veja este código:

object x = "mehdi emrani"; string y = "mehdi emrani"; Console.WriteLine(y == x); 

isso retorna true .

Mas esse código:

 object x = "mehdi emrani"; string y = "mehdi "; y += "emrani"; Console.WriteLine(y == x); 

retorna false .

Então, quando eu comparo String e Object no primeiro código, fico true .
Mas quando os comparo no segundo código, fico false .

Ambas as strings são iguais, mas por que quando eu adiciono a string, meu resultado retorna false ?

Em cada caso, o segundo operando de == é x , que é do tipo object . Isso significa que você está usando o operador de igualdade de referência normal.

Agora, no seu primeiro caso, você está usando duas constantes de string com o mesmo conteúdo. O compilador C # usará um único object para essas duas referências. No segundo caso, y referem-se a objects distintos de string com o mesmo conteúdo. As duas referências serão diferentes, então == retornará falso.

Você pode corrigir a comparação por:

  • Use Equals vez disso – isso é substituído por string (em oposição ao operador == que está sobrecarregado apenas:

     Console.WriteLine(y.Equals(x)); // or x.Equals(y), or Equals(y, x) 

    O uso do método estático Equals(object, object) pode ser útil se um dos argumentos puder ser nulo; Isso significa que você não precisa se preocupar com um NullReferenceException .

  • Faça as duas variables ​​do tipo string , no ponto em que a sobrecarga == dentro da string será selecionada em tempo de compilation, e essa sobrecarga compara o conteúdo das strings, não apenas as referências

Vale a pena notar que não é apenas uma questão de os próprios literais de string serem notados pelo compilador C # – é sobre expressões constantes em tempo de compilation. Então, por exemplo:

 object x = "mehdi emrani"; string y = "mehdi " + "emrani"; Console.WriteLine(y == x); // True 

Aqui y é inicializado usando dois literais de string que não são o mesmo que o usado para inicializar x , mas a concatenação de string é executada pelo compilador, que percebe que é a mesma string que já é usada para x .

Quando você inicializou

 object x = "mehdi emrani"; //pointer(x) 

Inicializou-o na memory e atribuiu a referência a x. Depois disso, quando você inicializou

 string y = "mehdi emrani"; //pointer(x) 

ref

O compilador acha que esse valor já está na memory, então ele atribui a mesma referência a y.

Agora o operador == equal que realmente compara os endereços em vez de value encontra o mesmo endereço para ambas as variables ​​que resultam true:

 x==y //actually compares pointer(x)==pointer(x) which is true 

No segundo caso, quando você inicializou x e y que receberam endereços diferentes.

 object x = "mehdi emrani"; //Pointer(x) string y = "mehdi "; //not found in memory y += "emrani"; //Pointer(y) 

Agora a comparação encontra endereços diferentes cujos resultados são falsos:

 x == y //is actually Pointer(x) == Pointer(y) which is false 

Então, para superar isso, você precisa usar .Equals () que, em vez de referência, compara o valor e o tipo de object.

 Console.WriteLine(y.Equals(x)); //compares "mehdi emrani" == "mehdi emrani" results true 

Muito provavelmente as referências são comparadas (implementação de Equals padrão para object). No primeiro exemplo, C # otimiza as strings constantes, e y e x na verdade apontam para o mesmo object, portanto, sua referência é igual. No outro caso, y é criado dinamicamente e, portanto, a referência é diferente.

No fundo, uma nova string é criada toda vez que você modifica uma existente, porque as strings são imutáveis, o que significa que elas não podem mudar.

Veja o seguinte para uma explicação: Por que o .NET String é imutável?

No primeiro caso, o .NET executa a otimização de seqüência constante e aloca apenas uma instância de String. Tanto x quanto y apontam para o mesmo object (ambas as referências são iguais).

Mas no segundo caso, xey estão apontando para instâncias de String diferentes. Adicionar “ermani” a y cria um terceiro object de string.

O operador “==” basicamente retorna true se os operandos de ambos os lados se referirem ao mesmo object. No primeiro caso, x e y referem-se ao mesmo object e, no segundo caso, x e y referem objects diferentes.

Você tentou:

 Console.WriteLine(y == x.ToString());