Esiste un operatore uguale a maiuscole e minuscole C #?

So che quanto segue distingue tra maiuscole e minuscole:

if (StringA == StringB) {

Quindi esiste un operatore che confronterà due stringhe in modo insensibile?

Prova questo:

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

Il modo migliore per confrontare 2 stringhe ignorando il caso delle lettere è utilizzare il metodo statico String.Equals che specifica un confronto di stringhe di maiuscole ordinali. Questo è anche il modo più veloce, molto più veloce di convertire le stringhe in lettere minuscole o maiuscole e confrontarle successivamente.

Ho testato le prestazioni di entrambi gli approcci e il confronto tra stringhe di casi ignorate ordinali è stato più di 9 volte più veloce ! È anche più affidabile della conversione di stringhe in lettere minuscole o maiuscole (controlla il problema turco i). Quindi usa sempre il metodo String.Equals per confrontare le stringhe per l'uguaglianza:

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

Se si desidera eseguire un confronto di stringhe specifico della cultura, è possibile utilizzare il seguente codice:

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

Si noti che il secondo esempio utilizza la logica di confronto delle stringhe della cultura corrente, che lo rende più lento rispetto al confronto "ordinale ignora caso" nel primo esempio, quindi se non è necessaria alcuna logica di confronto delle stringhe specifica della cultura e si è dopo il massimo delle prestazioni, utilizzare il confronto "ordinale ignora caso".

Per ulteriori informazioni, leggi la storia completa sul mio blog .

Esistono numerose proprietà nella StringComparerclasse statica che restituiscono comparatori per qualsiasi tipo di distinzione tra maiuscole e minuscole che potresti desiderare:

StringComparer Proprietà

Ad esempio, puoi chiamare

StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2)

o

StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2)

È un po 'più pulito di string.Equalso string.Comparesovraccarichi che accettano una StringComparisondiscussione.

System.Collections.CaseInsensitiveComparer

o

System.StringComparer.OrdinalIgnoreCase

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

o

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

ma devi assicurarti che StringA non sia null. Quindi probabilmente meglio usare:

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

come ha suggerito John

EDIT: corretto l'errore

Puoi usare

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

Operatore? No, ma penso che tu possa cambiare la tua cultura in modo che il confronto delle stringhe non sia sensibile al maiuscolo / minuscolo.

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

Sono fiducioso che cambierà il modo in cui le stringhe vengono confrontate dall'operatore uguale.

Ecco un'idea per semplificare la sintassi:

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

Utilizzabile come:

Console.WriteLine((IgnoreCase) "a" == "b"); // false
Console.WriteLine((IgnoreCase) "abc" == "abC"); // true
Console.WriteLine((IgnoreCase) "Abc" == "aBc"); // true
Console.WriteLine((IgnoreCase) "ABC" == "ABC"); // true

Sono così abituato a scrivere alla fine di questi metodi di confronto: , StringComparison.

Quindi ho fatto un'estensione.

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

Basta notare che sarà necessario verificare la presenza di null thisStringprima di chiamare ext.

string.Compare(string1, string2, true)

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

Le persone segnalano che ToUpperInvariant () è più veloce di ToLowerInvariant ().

Altri rispondono qui sono totalmente validi, ma in qualche modo ci vuole un po 'di tempo per scrivere StringComparison.OrdinalIgnoreCasee usare String.Compare.

Ho codificato un semplice metodo di estensione String, in cui è possibile specificare se il confronto fa distinzione tra maiuscole e minuscole o insensato con booleano - vedere la risposta seguente:

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