.net - Comment rendre IEnumerable<string>.Contains insensible à la casse?




arrays linq (4)

Si pour une raison quelconque vous préférez ou êtes obligé d'utiliser StringComparison et non pas StringComparer , vous pouvez ajouter une méthode d'extension comme suit:

public static bool Contains(this IEnumerable<string> items, string value, StringComparison stringComparison)
{
    StringComparer stringComparer;

    switch (stringComparison)
    {
        case StringComparison.CurrentCulture:
            stringComparer = StringComparer.CurrentCulture;
            break;
        case StringComparison.CurrentCultureIgnoreCase:
            stringComparer = StringComparer.CurrentCultureIgnoreCase;
            break;
        case StringComparison.InvariantCulture:
            stringComparer = StringComparer.InvariantCulture;
            break;
        case StringComparison.InvariantCultureIgnoreCase:
            stringComparer = StringComparer.InvariantCultureIgnoreCase;
            break;
        case StringComparison.Ordinal:
            stringComparer = StringComparer.Ordinal;
            break;
        case StringComparison.OrdinalIgnoreCase:
            stringComparer = StringComparer.OrdinalIgnoreCase;
            break;
        default:
            throw new NotImplementedException();
    }

    return items.Contains(value, stringComparer);
}

Vous trouverez plus de variations sur la façon de les cartographier dans cette question .

Supposons que j'ai un tableau .net de chaînes.

string[] strings = new string[] { "AbC", "123", "Xyz", "321" };

Si je voulais voir si le tableau de chaînes contient "ABC", je pourrais écrire

strings.Contains("ABC");

Cependant, supposons que je veuille une fonction qui retourne true si les valeurs majuscules des chaînes contiennent "ABC". Je pourrais mettre tout le tableau en majuscule, mais il semble que la méthode .Contains comporte des surcharges pour spécifier la comparaison, mais la syntaxe m'embrouille.

Comment utiliser la méthode IEnumerable<string>.Contains() pour implémenter cette logique?


Utilisez la méthode surchargée Enumerable.Contains qui accepte le comparateur d'égalité:

strings.Contains("ABC", StringComparer.InvariantCultureIgnoreCase)

Il y a aussi un comparateur de chaînes dans la boîte que vous pouvez utiliser.


J'aime personnellement le LambdaComparer ce type, qui est vraiment utile pour des choses comme celle-ci:

LINQ vos collections avec IEqualityComparer et les expressions Lambda

Exemple d'utilisation:

var comparer = new LambdaComparer<string>(
    (lhs, rhs) => lhs.Equals(rhs, StringComparison.InvariantCultureIgnoreCase));

var seq = new[]{"a","b","c","d","e"};

Debug.Assert(seq.Contains("A", comparer));

Si vous utilisez underscore.js ou Lo-Dash , la bibliothèque underscore.string fournit des extensions de chaîne, notamment des majuscules:

_.capitalize (string) Convertit la première lettre de la chaîne en majuscule.

Exemple:

_.capitalize("foo bar") == "Foo bar"




.net arrays string linq