Y a-t-il un opérateur égal insensible à la casse c#?

La meilleure façon pour comparer 2 chaînes en ignorant la casse des lettres est d'utiliser le String.Est égal à méthode statique spécifiant une comparaison de chaîne de casse ignorée ordinale. C'est aussi le moyen le plus rapide, beaucoup plus rapide que de convertir les chaînes en minuscules ou majuscules et de les comparer après cela.

J'ai testé les performances des deux approches et la comparaison ordinale des chaînes de cas ignorées était plus de 9 fois plus rapide! Il est également plus fiable que la conversion chaînes en minuscules ou majuscules (consultez le problème Turc i). Donc, utilisez toujours la chaîne .Equals méthode pour comparer les chaînes pour l'égalité:

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

Si vous souhaitez effectuer une comparaison de chaîne spécifique à la culture, vous pouvez utiliser le code suivant:

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

Veuillez noter que le deuxième exemple utilise la logique de comparaison de chaîne de la culture actuelle, ce qui la rend plus lente que la comparaison "ordinale ignore case" dans le premier exemple, donc si vous n'avez pas besoin de culture logique de comparaison de chaîne spécifique et vous êtes après une performance maximale, utilisez la comparaison "ordinal ignore case".

Pour plus d'informations, lire l'article complet sur mon blog.

Il y a un certain nombre de propriétés sur la classe statique StringComparer qui renvoient des comparateurs pour tout type de sensibilité à la casse que vous pourriez vouloir:

StringComparer Propriétés

, Par exemple, vous pouvez appeler

StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2)

Ou

StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2)

C'est un peu plus propre que les surcharges string.Equals ou string.Compare qui prennent un StringComparison argument.

System.Collections.CaseInsensitiveComparer

Ou

System.StringComparer.OrdinalIgnoreCase

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

Ou

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

Mais vous devez être sûr que StringA n'est pas null. Donc probablement mieux Tu utiliser:

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

Comme John l'a suggéré

EDIT: correction du bug

Vous pouvez utiliser

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

Opérateur? Non, mais je pense que vous pouvez changer votre culture pour que la comparaison de chaînes ne soit pas sensible à la casse.

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

Je suis confiant qu'il va changer la façon dont les chaînes sont comparées par l'opérateur=.

Je suis tellement habituée à taper à la fin de ces méthodes de comparaison: , StringComparison.

J'ai donc fait une prolongation.

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

Notez simplement que vous devrez vérifier la valeur null sur thisString avant d'appeler l'ext.

Voici une idée pour simplifier la syntaxe:

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

Utilisable comme:

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()) {

Les gens rapportent que ToUpperInvariant () est plus rapide que ToLowerInvariant ().

Les autres réponses sont totalement valides ici, mais il faut du temps pour taper StringComparison.OrdinalIgnoreCase et aussi utiliser String.Compare.

J'ai codé une méthode D'extension de chaîne simple, où vous pouvez spécifier si la comparaison est sensible à la casse ou insensée avec booléen - voir la réponse suivante:

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