¿Hay un operador de C # insensible a mayúsculas y minúsculas?

Sé que lo siguiente distingue entre mayúsculas y minúsculas:

if (StringA == StringB) {

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

Prueba esto:

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

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

¡Probé el rendimiento de ambos enfoques y la comparación de cadena de caso de ignorar ordinal fue más de 9 veces más rápida ! También es más confiable que convertir cadenas a minúsculas o mayúsculas (consulte el problema turco i). Por lo tanto, use siempre 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ífica de la 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 de ignorar ordinal" en el primer ejemplo, por lo que si no necesita ninguna lógica de comparación de cadenas específica de la cultura y está después del máximo rendimiento, use la comparación "ignorar el caso ordinal".

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

Hay una serie de propiedades en la StringComparerclase estática que devuelven comparadores para cualquier tipo de mayúsculas y minúsculas que desee:

StringComparer Propiedades

Por ejemplo, puedes llamar

StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2)

o

StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2)

Es un poco más limpio que las sobrecargas string.Equalso string.Compareque toman una StringComparisondiscusión.

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. Así que probablemente sea mejor que uses:

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

como John sugirió

EDITAR: corrigió el error

Puedes usar

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

¿Operador? NO, pero creo que puede cambiar su 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.

Aquí una idea para simplificar la sintaxis:

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

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

Entonces 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 si hay nulo activado thisStringantes de llamar a la ext.

string.Compare(string1, string2, true)

if (StringA.ToUpperInvariant() == StringB.ToUpperInvariant()) {

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

Las respuestas de otros son totalmente válidas aquí, pero de alguna manera lleva algún tiempo escribirlas StringComparison.OrdinalIgnoreCasey usarlas String.Compare.

Codifiqué un método de extensión de cadena simple, donde podría especificar si la comparación distingue entre mayúsculas y minúsculas y no tiene mayúsculas y minúsculas con boolean: consulte la siguiente respuesta:

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