¿Hay un caso insensible a C # es igual a operador?

Sé que el siguiente es sensible a mayúsculas y minúsculas:

if (StringA == StringB) { 

Entonces, ¿hay un operador que compare dos cuerdas de manera insensible?

Prueba esto:

 string.Equals(a, b, StringComparison.CurrentCultureIgnoreCase); 

La mejor manera de comparar 2 cadenas ignorando el caso de las letras es usar el método estático String.Equals que especifica una comparación ordinal de cadenas de casos ignoradas. Esta es también la forma más rápida, mucho más rápida que convertir las cuerdas en mayúsculas o minúsculas y compararlas después de eso.

¡Probé el rendimiento de ambos enfoques y la comparación de cadenas de casos omisión ordinal fue más de 9 veces más rápida ! También es más confiable que la conversión de cadenas a mayúsculas o minúsculas (consulte el problema turco i). Por lo tanto, siempre use el método String.Equals para comparar cadenas de igualdad:

 String.Equals(string1, string2, StringComparison.OrdinalIgnoreCase); 

Si desea realizar una comparación de cadenas específicas de cultura, puede usar el siguiente código:

 String.Equals(string1, string2, StringComparison.CurrentCultureIgnoreCase); 

Tenga en cuenta que el segundo ejemplo utiliza la lógica de comparación de cadenas de la cultura actual, lo que lo hace más lento que la comparación de “caso omiso ordinal” en el primer ejemplo, por lo que si no necesita ninguna lógica de comparación de cadenas específica de cultura y está después del rendimiento máximo, use la comparación “caso omiso ordinal”.

Para obtener más información, lea la historia completa en mi blog .

Hay una serie de propiedades en la clase estática StringComparer que devuelven comparadores para cualquier tipo de distinción entre mayúsculas y minúsculas que pueda desear:

Propiedades de StringComparer

Por ejemplo, puedes llamar

 StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2) 

o

 StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2) 

Es un poco más limpio que el string.Equals o string.Compare sobrecargas que toman un argumento de StringComparison .

 System.Collections.CaseInsensitiveComparer 

o

 System.StringComparer.OrdinalIgnoreCase 
 string.Equals(StringA, StringB, StringComparison.CurrentCultureIgnoreCase); 

o

 if (StringA.Equals(StringB, StringComparison.CurrentCultureIgnoreCase)) { 

pero debe asegurarse de que StringA no sea nulo. Entonces probablemente sea mejor tu uso:

 string.Equals(StringA , StringB, StringComparison.CurrentCultureIgnoreCase); 

como sugirió John

EDITAR: corrigió el error

Puedes usar

 if (stringA.equals(StringB, StringComparison.CurrentCultureIgnoreCase)) 

¿Operador? NO, pero creo que puedes cambiar tu cultura para que la comparación de cadenas no distinga entre mayúsculas y minúsculas.

 // you'll want to change this... System.Threading.Thread.CurrentThread.CurrentCulture // and you'll want to custimize this System.Globalization.CultureInfo.CompareInfo 

Estoy seguro de que cambiará la forma en que el operador de igualdad compara las cadenas.

Estoy tan acostumbrado a escribir al final de estos métodos de comparación: , StringComparison.

Así que hice una extensión.

 namespace System { public static class StringExtension { public static bool Equals(this string thisString, string compareString, StringComparison stringComparison) { return string.Equals(thisString, compareString, stringComparison); } } } 

Solo tenga en cuenta que deberá verificar null en thisString antes de llamar al ext.

Aquí una idea para simplificar la syntax:

 public class IgnoreCase { private readonly string _value; public IgnoreCase(string s) { _value = s; } protected bool Equals(IgnoreCase other) { return this == other; } public override bool Equals(object obj) { return obj != null && (ReferenceEquals(this, obj) || (obj.GetType() == GetType() && this == (IgnoreCase) obj)); } public override int GetHashCode() { return _value?.GetHashCode() ?? 0; } public static bool operator ==(IgnoreCase a, IgnoreCase b) { return string.Equals(a, b, StringComparison.OrdinalIgnoreCase); } public static bool operator !=(IgnoreCase a, IgnoreCase b) { return !(a == b); } public static implicit operator string(IgnoreCase s) { return s._value; } public static implicit operator IgnoreCase(string s) { return new IgnoreCase(s); } } 

Utilizable como:

 Console.WriteLine((IgnoreCase) "a" == "b"); // false Console.WriteLine((IgnoreCase) "abc" == "abC"); // true Console.WriteLine((IgnoreCase) "Abc" == "aBc"); // true Console.WriteLine((IgnoreCase) "ABC" == "ABC"); // true 
 string.Compare(string1, string2, true) 
 if (StringA.ToUpperInvariant() == StringB.ToUpperInvariant()) { 

Las personas informan que ToUpperInvariant () es más rápido que ToLowerInvariant ().

Otras respuestas son totalmente válidas aquí, pero de alguna manera lleva tiempo StringComparison.OrdinalIgnoreCase y también usar String.Compare .

He codificado el método simple de extensión de cadena, donde puedes especificar si la comparación es sensible a mayúsculas y minúsculas o no tiene sentido con booleano; consulta la siguiente respuesta:

https://stackoverflow.com/a/49208128/2338477