it-swarm.com.de

Gibt es einen C # -unabhängigen Gleichheitsoperator?

Ich weiß, dass Folgendes die Groß- und Kleinschreibung berücksichtigt:

if (StringA == StringB) {

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

144
GateKiller

Versuche dies:

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

Der beste Weg zum Vergleichen von 2 Zeichenfolgen, wobei die Schreibweise der Buchstaben ignoriert wird, ist die Verwendung der statischen Methode String.Equals . Dies ist auch der schnellste Weg, viel schneller, als die Zeichenfolgen in Klein- oder Großbuchstaben umzuwandeln und sie danach zu vergleichen.

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

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

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

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

Bitte beachten Sie, dass das zweite Beispiel die Stringvergleichslogik der aktuellen Kultur verwendet, was es langsamer macht als der Vergleich "Ordinal-Ignorierfall" im ersten Beispiel. Wenn Sie also keine kulturspezifische Stringvergleichslogik benötigen, ist dies der Fall Verwenden Sie nach maximaler Leistung den Vergleich "Ordinalwert ignorieren".

Weitere Informationen erhalten Sie lesen Sie den gesamten Artikel in meinem Blog .

26
Pavel Vladov

In der statischen Klasse StringComparer gibt es eine Reihe von Eigenschaften, die Vergleicher für alle Arten von Groß- und Kleinschreibung, die Sie möchten, zurückgeben:

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.Equals- oder string.Compare-Überladungen, die ein StringComparison -Argument erfordern.

17
Ryan Lundy
System.Collections.CaseInsensitiveComparer

oder

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

oder

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

sie müssen jedoch sicherstellen, dass StringA nicht null ist. Also wahrscheinlich besser zu gebrauchen:

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

wie John vorschlug

BEARBEITEN: Fehler behoben

7
Grzenio

Sie können verwenden 

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

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

Operator? NEIN, aber ich denke, Sie können Ihre Kultur ändern, sodass der Zeichenfolgenvergleich nicht zwischen Groß- und Kleinschreibung unterscheidet.

// 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 dies die Art und Weise verändern wird, in der Strings vom Operator equals verglichen werden.

3
John Leidegren

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, dass Sie vor dem Aufruf von ext auf thisString auf null prüfen müssen.

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

Andere Antworten sind hier völlig gültig, aber es dauert einige Zeit, StringComparison.OrdinalIgnoreCase einzugeben und auch String.Compare zu verwenden.

Ich habe eine einfache String-Erweiterungsmethode codiert, in der Sie angeben können, ob bei boolean zwischen Groß- und Kleinschreibung unterschieden wird.

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

0
TarmoPikaro

Mach einfach

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

Schreiben Sie dann StringB in Kleinbuchstaben, um auch stringB.toLower() auszuführen.

.toLower() gibt eine Kopie der Zeichenfolge als Kleinbuchstaben zurück und ändert daher die ursprüngliche Zeichenfolge nicht.

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

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

0
knoopx