Hoe maak je IEnumerable<string>.Bevat hoofdletterongevoelig?

Stel dat ik een .net-array van strings heb.

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

Als ik wilde zien of de reeks strings “ABC” bevat, zou ik kunnen schrijven

strings.Contains("ABC");

Stel echter dat ik een functie wil die true retourneert als de hoofdletterwaarden van de strings “ABC” bevatten. Ik zou de hele array in hoofdletters kunnen zetten, maar het lijkt erop dat de methode .Containswat overbelasting heeft voor het specificeren van de vergelijking, maar ik ben in de war door de syntaxis.

Hoe kan ik de IEnumerable<string>.Contains()methode gebruiken om deze logica te implementeren?

Antwoord 1, autoriteit 100%

Gebruik een overbelaste Enumerable.Contains-methode die gelijkheidsvergelijking accepteert:

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

Er is ook een stringsvergelijkerin de doos die je kunt gebruiken.

Antwoord 2, autoriteit 2%

Persoonlijk vind ik de LambdaComparervan deze man goed, wat erg handig is voor dit soort dingen:

LINQ Uw collecties met IEqualityComparer en Lambda-uitdrukkingen

Voorbeeld van gebruik:

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

Antwoord 3

Als u om de een of andere reden de voorkeur geeft aan of gedwongen wordt om StringComparisonte gebruiken en niet StringComparer, kunt u als volgt een extensiemethode toevoegen:

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

Meer variaties op hoe deze in kaart te brengen zijn te vinden in deze vraag .