Czy istnieje operator niewrażliwy na wielkość liter w C#?

Najlepszym sposobem aby porównać 2 łańcuchy ignorując wielkość liter jest użycie String.Equals statyczna metoda określająca kolejność porównywania łańcuchów wielkości ignorowanych. Jest to również najszybszy sposób, znacznie szybszy niż konwersja łańcuchów na małe lub wielkie litery i porównywanie ich po tym.

Przetestowałem wydajność obu podejść i kolejność ignorowania łańcuchów znaków była ponad 9 razy szybsza ! Jest również bardziej niezawodny niż konwersja ciągi na małe lub duże litery(zobacz problem Turkish i). Więc zawsze używaj String.Equals metoda porównywania łańcuchów dla równości:

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

Jeśli chcesz przeprowadzić porównanie łańcuchów kulturowych, możesz użyć następującego kodu:

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

Zauważ, że drugi przykład wykorzystuje logikę porównywania łańcuchów bieżącej kultury, co sprawia, że jest ona wolniejsza niż porównanie "ordinal ignore case" w pierwszym przykładzie, więc jeśli nie potrzebujesz żadnej kultury specyficzna logika porównywania łańcuchów i jesteś po maksymalnej wydajności, użyj porównania "ordinal ignoruj wielkość liter".

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

Istnieje wiele właściwości StringComparer klasy statycznej, które zwracają porównywanie dla dowolnego typu czułości wielkości liter:

StringComparer właściwości

Na przykład, możesz zadzwonić

StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2)

Lub

StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2)

Jest nieco czystsze niż string.Equals lub string.Compare przeciążenia, które zajmują StringComparison kłótnia.

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 zerowa. Więc chyba lepiej tu używać:

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

Jak zasugerował John

EDIT: Poprawiono błąd

Możesz użyć

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

Operator? Nie, ale myślę, że możesz zmienić swoją kulturę tak, że porównywanie łańcuchów nie ma znaczenia 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 łańcuchów przez operatora equals.

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

Więc zrobiłem przedłużenie.

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

Pamiętaj, że przed wywołaniem ext musisz sprawdzić czy nie ma null na thisString.

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żyteczny 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

string.Compare(string1, string2, true)

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

Ludzie donoszą, że Toupperinvariant () jest szybszy niż ToLowerInvariant ().

Inne odpowiedzi są tutaj całkowicie poprawne, ale jakoś potrzeba czasu, aby wpisać StringComparison.OrdinalIgnoreCase, a także użyć String.Compare.

Zakodowałem prostą metodę rozszerzenia łańcucha znaków, w której możesz określić, czy porównanie ma rozróżniać wielkość liter, czy nie ma znaczenia wielkość liter za pomocą boolean-zobacz następującą odpowiedź:

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