web-dev-qa-db-fra.com

Existe-t-il un opérateur d'égalité insensible à la casse C #?

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

if (StringA == StringB) {

Existe-t-il un opérateur qui compare deux chaînes de manière insensible?

c#.netstringoperatorscase-insensitive
144
GateKiller

Essaye ça:

string.Equals(a, b, StringComparison.CurrentCultureIgnoreCase);
269
John Feminella

Le meilleur moyen de comparer 2 chaînes en ignorant la casse des lettres est d'utiliser la méthode String.Equals static en 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 majuscules ou minuscules et de les comparer par la suite.

J'ai testé les performances des deux approches et l'ordinal ignorer la comparaison des chaînes de casse était plus de 9 fois plus rapide! Il est également plus fiable que la conversion de chaînes en majuscules ou en minuscules (consultez le problème turc i). Donc, utilisez 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î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înes de la culture actuelle, ce qui la rend plus lente que la comparaison "casse ignorée" dans le premier exemple. Par conséquent, si vous n'avez pas besoin d'une logique de comparaison de chaînes spécifique à une culture, après des performances maximales, utilisez la comparaison "ordinal ignore case".

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

26
Pavel Vladov

Un certain nombre de propriétés de la classe statique StringComparer permettent de renvoyer des comparateurs pour tout type de respect de la casse souhaité:

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 argument StringComparison .

17
Ryan Lundy
System.Collections.CaseInsensitiveComparer

ou

System.StringComparer.OrdinalIgnoreCase
15
leppie
string.Equals(StringA, StringB, StringComparison.CurrentCultureIgnoreCase);
9
Erick

ou

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

mais vous devez être sûr que StringA n'est pas null. Donc, probablement une meilleure utilisation tu:

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

comme l'a suggéré John

EDIT: corrigé le bug

7
Grzenio

Vous pouvez utiliser 

if (stringA.equals(StringB, StringComparison.CurrentCultureIgnoreCase))
4
Andy Mikula

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
3
renouve

Opérateur? NON, mais je pense que vous pouvez changer de 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 convaincu que cela changera la façon dont l'opérateur compare le traitement des chaînes.

3
John Leidegren

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

Alors j'ai 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 thisString avant d'appeler le poste.

2
Valamas
string.Compare(string1, string2, true)
0
user25623

Les autres réponses sont tout à fait valables ici, mais il faut un certain temps pour taper StringComparison.OrdinalIgnoreCase et aussi pour utiliser String.Compare.

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

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

0
TarmoPikaro

Il suffit de faire

if (stringA.toLower() == stringB) {};

Ensuite, écrivez StringB en minuscule, pour faire aussi stringB.toLower().

.toLower() renvoie une copie de la chaîne en minuscule et ne modifiera donc pas la chaîne d'origine.

0
Ben Rauzi
if (StringA.ToUpperInvariant() == StringB.ToUpperInvariant()) {

Les utilisateurs signalent que ToUpperInvariant () est plus rapide que ToLowerInvariant ().

0
knoopx