c# confusos en la comparación de cadenas: ¿el operador string.equals () y el operador [&] == ?

En C#, las comparaciones de cadenas a veces producen resultados inesperados. Una pregunta común es si el método

string.equals () y el operador de signo igual == se comporta exactamente igual.

Considere el siguiente fragmento de código:

string s = "Category";
TreeViewItem tvi = new TreeViewItem();
tvi.Header = "Category";

Console.WriteLine(s == tvi.Header); // false
Console.WriteLine(s.Equals(tvi.Header)); // true
Console.WriteLine(s == tvi.Header.ToString()); // true

s

y tvi.header tvi.header ] tvi, el == operator devuelve falso string.equals () el método devuelve . Esto plantea la pregunta: ¿por qué estos dos métodos de comparación producen resultados diferentes? Diferencias clave entre

string.equals ()

y == Hay dos diferencias fundamentales entre string.equals () y ==

operadores:

] Tipo de implementación específica: el operador

==

que se compara en función del tipo de tiempo de compilación del objeto, mientras que
1. string.equals () es polimórfica, lo que significa que su implementación depende del tipo de tiempo de ejecución del objeto que se compara. NULL Value Processing: ==
El operador no arrojará una excepción al comparar referencias nulo, mientras
2. string.equals () si algún parámetro está vacío, a nullreferencexception se lanzará excepción. Ejemplo de demostración de diferencias
]

Para ilustrar estas diferencias, considere el siguiente código:

objeto x = new StringBuilder ("Hello"). ToString (); objeto y = nuevo StringBuilder ("Hello"). ToString (); if (x.equals (y)) // Verdadero if (x == y) // false

aunque el

object x = new StringBuilder("hello").ToString();
object y = new StringBuilder("hello").ToString();

if (x.Equals(y)) // True

if (x == y) // False

y

] y ] Operator devuelve falso porque se compara en función del tipo de tiempo de compilación del objeto ( objeto que son diferentes. Para obtener la comparación correcta, el objeto debe convertirse explícitamente al tipo apropiado (en este caso string ). string xs = (string) x; cadena ys = (string) y; if (xs == ys) // true

string xs = (string)x;
string ys = (string)y;

if (xs == ys) // True

mientras que los operadores

string.equals () y ==

generalmente se usan indistintamente, es importante comprender sus matices en la implementación y el procesamiento de valor nulo. Para garantizar comparaciones de cadenas confiables y consistentes, generalmente se recomienda el método

string.equals () , especialmente cuando se comparan diferentes tipos de objetos o maneje referencias vacías.