Gibt es einen C # Groß- / Kleinschreibung ohne Berücksichtigung des Operators?

Ich weiß, dass bei Folgendem zwischen Groß- und Kleinschreibung unterschieden wird:

if (StringA == StringB) {

Gibt es also einen Operator, der zwei Zeichenfolgen unempfindlich vergleicht?

Versuche dies:

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

Der beste Weg , um zwei Zeichenfolgen zu vergleichen, wobei die Groß- und Kleinschreibung der Buchstaben ignoriert wird, ist die statische Methode String.Equals , mit der ein Vergleich der Zeichenfolgen für die Groß- und Kleinschreibung angegeben wird. Dies ist auch der schnellste Weg, viel schneller als die Zeichenfolgen in Klein- oder Großbuchstaben umzuwandeln und danach zu vergleichen.

Ich habe die Leistung beider Ansätze getestet und der Vergleich der ordinalen Ignorierfallzeichenfolgen war mehr als neunmal schneller ! Es ist auch zuverlässiger als das Konvertieren von Zeichenfolgen in Klein- oder Großbuchstaben (siehe das türkische i-Problem). Verwenden Sie daher immer die String.Equals- Methode, um Zeichenfolgen auf Gleichheit zu vergleichen:

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

Wenn Sie einen kulturspezifischen Zeichenfolgenvergleich durchführen möchten, können Sie den folgenden Code verwenden:

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

Bitte beachten Sie, dass im zweiten Beispiel die Zeichenfolgenvergleichslogik der aktuellen Kultur verwendet wird, wodurch sie langsamer ist als der Vergleich "Ordinaler Ignorierfall" im ersten Beispiel. Wenn Sie also keine kulturspezifische Zeichenfolgenvergleichslogik benötigen und dies auch sind Verwenden Sie nach maximaler Leistung den Vergleich "Ordinaler Ignorierfall".

Weitere Informationen finden Sie in meinem Blog .

Es gibt eine Reihe von Eigenschaften für die StringComparerstatische Klasse, die Vergleicher für jede Art von Groß- und Kleinschreibung zurückgeben, die Sie möglicherweise wünschen:

StringComparer Eigenschaften

Zum Beispiel können Sie anrufen

StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2)

oder

StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2)

Es ist ein bisschen sauberer als die string.Equalsoder string.CompareÜberladungen, die ein StringComparisonArgument erfordern.

System.Collections.CaseInsensitiveComparer

oder

System.StringComparer.OrdinalIgnoreCase

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

oder

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

Sie müssen jedoch sicherstellen, dass StringA nicht null ist. Also wahrscheinlich besser für:

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

wie John vorschlug

BEARBEITEN: Fehler behoben

Sie können verwenden

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

Operator? NEIN, aber ich denke, Sie können Ihre Kultur ändern, sodass beim Vergleich von Zeichenfolgen nicht zwischen Groß- und Kleinschreibung unterschieden wird.

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

Ich bin zuversichtlich, dass sich dadurch die Art und Weise ändern wird, in der Zeichenfolgen vom Gleichheitsoperator verglichen werden.

Hier eine Idee zur Vereinfachung der Syntax:

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

Verwendbar wie:

Console.WriteLine((IgnoreCase) "a" == "b"); // false
Console.WriteLine((IgnoreCase) "abc" == "abC"); // true
Console.WriteLine((IgnoreCase) "Abc" == "aBc"); // true
Console.WriteLine((IgnoreCase) "ABC" == "ABC"); // true

Ich bin es gewohnt, am Ende dieser Vergleichsmethoden zu tippen: , StringComparison.

Also habe ich eine Erweiterung gemacht.

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

Beachten Sie nur, dass Sie thisStringvor dem Aufruf von ext auf null prüfen müssen .

string.Compare(string1, string2, true)

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

Leute berichten, dass ToUpperInvariant () schneller ist als ToLowerInvariant ().

Andere Antworten sind hier völlig gültig, aber irgendwie dauert es einige Zeit, sie zu tippen StringComparison.OrdinalIgnoreCaseund auch zu verwenden String.Compare.

Ich habe eine einfache String-Erweiterungsmethode codiert, bei der Sie angeben können, ob beim Vergleich zwischen Groß- und Kleinschreibung oder Boolescher Wert zwischen Groß- und Kleinschreibung unterschieden wird - siehe folgende Antwort:

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