Czy istnieje operator równości bez uwzględniania wielkości liter w języku C #?

Wiem, że rozróżniana jest wielkość liter:

if (StringA == StringB) {

Czy jest więc operator, który porównuje dwa ciągi w niewrażliwy sposób?

Spróbuj tego:

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

Najlepszym sposobem porównania 2 łańcuchów ignorujących wielkość liter jest użycie statycznej metody String.Equals , określającej porównanie ciągów liczb porządkowych ignorujących wielkość liter . Jest to również najszybszy sposób, znacznie szybszy niż konwersja ciągów znaków na małe lub duże litery i ich późniejsze porównywanie.

Przetestowałem wydajność obu podejść i porównanie ciągów znaków porządkowych ignorujących wielkość liter było ponad 9 razy szybsze ! Jest również bardziej niezawodny niż konwersja ciągów znaków na małe lub duże litery (sprawdź turecki problem i). Dlatego zawsze używaj metody String.Equals , aby porównać ciągi znaków dla równości:

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

Jeśli chcesz przeprowadzić porównanie ciągów specyficznych dla kultury, możesz użyć następującego kodu:

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

Zwróć uwagę, że w drugim przykładzie użyto logiki porównywania ciągów bieżącej kultury, co powoduje, że jest ona wolniejsza niż porównanie „porządkowego ignorowania wielkości liter” w pierwszym przykładzie, więc jeśli nie potrzebujesz żadnej logiki porównywania ciągów specyficznej dla kultury i jesteś po osiągnięciu maksymalnej wydajności użyj porównania „porządkowa ignoruj ​​wielkość liter”.

Aby uzyskać więcej informacji, przeczytaj całą historię na moim blogu .

Istnieje wiele właściwości w StringComparerklasie statycznej, które zwracają elementy porównujące dla dowolnego typu rozróżniania wielkości liter:

StringComparer Nieruchomości

Na przykład możesz zadzwonić

StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2)

lub

StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2)

Jest trochę czystszy niż przeciążenia string.Equalslub, string.Comparektóre przyjmują StringComparisonargument.

System.Collections.CaseInsensitiveComparer

lub

System.StringComparer.OrdinalIgnoreCase

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

lub

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

ale musisz mieć pewność, że StringA nie jest null. Więc prawdopodobnie lepiej użyć:

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

jak zasugerował John

EDYCJA: poprawiono błąd

Możesz użyć

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

Operator? NIE, ale myślę, że możesz zmienić swoją kulturę, aby w porównaniu ciągów nie była rozróżniana wielkość liter.

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

Jestem przekonany, że zmieni to sposób porównywania ciągów znaków przez operator równości.

Oto pomysł na uproszczenie składni:

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

Użyteczne jak:

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

Jestem przyzwyczajony do pisania na końcu tych metod porównawczych: , StringComparison.

Więc zrobiłem rozszerzenie.

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

Zwróć uwagę, że thisStringprzed wywołaniem rozszerzenia ext.

string.Compare(string1, string2, true)

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

Ludzie zgłaszają, że ToUpperInvariant () jest szybsze niż ToLowerInvariant ().

Inne odpowiedzi są tutaj całkowicie poprawne, ale w jakiś sposób wpisanie StringComparison.OrdinalIgnoreCasei użycie zajmuje trochę czasu String.Compare.

Zakodowałem prostą metodę rozszerzenia String, w której możesz określić, czy porównanie ma rozróżniać wielkość liter, czy bez sensu z wartością logiczną - zobacz następującą odpowiedź:

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