Existe-t-il un opérateur égal insensible à la casse C #?

Je sais que ce qui suit est sensible à la casse:

if (StringA == StringB) {

Y a-t-il donc un opérateur qui comparera deux chaînes de manière insensible?

Essaye ça:

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

La meilleure façon de comparer 2 chaînes en ignorant la casse des lettres est d'utiliser la méthode statique String.Equals en spécifiant une comparaison de chaîne ordinale ignorant la casse. 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 ensuite.

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

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

Si vous souhaitez effectuer une comparaison de chaînes spécifiques à une 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înes de la culture actuelle, ce qui la rend plus lente que la comparaison "ordinal ignore case" dans le premier exemple, donc si vous n'avez pas besoin d'une logique de comparaison de chaînes spécifique à la culture et que vous êtes après des performances maximales, utilisez la comparaison «ordinal ignorer la casse».

Pour plus d'informations, lisez l'histoire complète sur mon blog .

Il existe un certain nombre de propriétés sur la StringComparerclasse statique qui renvoient des comparateurs pour tout type de sensibilité à la casse que vous pourriez souhaiter:

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.Equalsou string.Comparequi prennent un StringComparisonargument.

System.Collections.CaseInsensitiveComparer

ou

System.StringComparer.OrdinalIgnoreCase

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

ou

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

mais vous devez vous assurer que StringA n'est pas nul. Il vaut donc probablement mieux 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 afin 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 convaincu que cela changera la façon dont les chaînes sont comparées par l'opérateur égal.

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

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

J'ai donc fait une extension.

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 thisStringavant d'appeler le poste.

string.Compare(string1, string2, true)

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

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

D'autres réponses sont totalement valables ici, mais d'une manière ou d'une autre, il faut un certain temps pour taper StringComparison.OrdinalIgnoreCaseet utiliserString.Compare .

J'ai codé la méthode d'extension de chaîne simple, dans laquelle vous pouvez spécifier si la comparaison est sensible à la casse ou à la casse avec booléen - voir la réponse suivante:

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