Różnica między InvariantCulture a Ordinal string string

Porównując dwa ciągi w c # dla równości, jaka jest różnica między InvariantCulture a Ordinal porównaniem?

InvariantCulture

Wykorzystuje „standardowy” zestaw uporządkowania znaków (a, b, c, ... itd.). Jest to sprzeczne z niektórymi konkretnymi ustawieniami regionalnymi, które mogą sortować znaki w różnych porządkach („a-z-ostrym” może występować przed lub po „a”, w zależności od ustawień regionalnych itd.).

Porządkowy

Z drugiej strony, patrzy wyłącznie na wartości surowych bajtów, które reprezentują znak.

Świetna próbka znajduje się na stronie http://msdn.microsoft.com/en-us/library/e6883c06.aspx, która pokazuje wyniki różnych wartości StringComparison. Na samym końcu pokazuje (fragment):

StringComparison.InvariantCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.Ordinal:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is greater than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

Widać, że tam, gdzie przynosi InvariantCulture (U + 0069, U + 0049, U + 00131), Zwykłe plony (U + 0049, U + 0069, U + 00131).

Ma to na przykład znaczenie - istnieje tzw. Ekspansja postaci

var s1 = "Strasse";
var s2 = "Straße";

s1.Equals(s2, StringComparison.Ordinal);           //false
s1.Equals(s2, StringComparison.InvariantCulture);  //true

Z InvariantCultureß znak zostaje rozszerzony do ss.

Wskazując na najlepsze praktyki korzystania z ciągów w .NET Framework :

• Użyj StringComparison.Ordinallub StringComparison.OrdinalIgnoreCasedo porównań jako bezpiecznego domyślnego dopasowania łańcucha bez względu na kulturę.
• Użyj porównań z StringComparison.Ordinallub StringComparison.OrdinalIgnoreCasedla lepszej wydajności.
• Użyj operacji niejęzykowych StringComparison.Ordinallub StringComparison.OrdinalIgnoreCasewartości zamiast operacji na łańcuchach, w oparciu o to, CultureInfo.InvariantCulturekiedy porównanie nie ma znaczenia językowego (na przykład symboliczne).

I w końcu:

• StringComparison.InvariantCultureW większości przypadków nie należy używać operacji na łańcuchach . Jednym z nielicznych wyjątków jest utrwalanie znaczących językowo, ale kulturowo agnostycznych danych.

Inną przydatną różnicą (w języku angielskim, gdzie akcenty są rzadkie) jest to, że porównanie InvariantCulture porównuje najpierw wszystkie ciągi znaków bez rozróżniania wielkości liter, a następnie, jeśli to konieczne (i wymagane), rozróżnia je po pierwszym, porównując tylko poszczególne litery. (Oczywiście można również przeprowadzić porównanie bez rozróżniania wielkości liter, które nie rozróżnia wielkości liter.) Poprawiono:Litery akcentowane są uważane za inny smak tych samych liter i ciąg jest porównywany najpierw ignorując akcenty, a następnie rozliczając je, jeśli wszystkie litery ogólne pasują (podobnie jak w przypadku różnych liter, z wyjątkiem tego, że ostatecznie nie jest ignorowane w porównaniu bez rozróżniania wielkości liter). Ta grupa akcentuje wersje skądinąd tego samego słowa blisko siebie, zamiast całkowicie rozdzielić przy pierwszej różnicy akcentu. Jest to kolejność sortowania, którą zwykle można znaleźć w słowniku: słowa pisane wielkimi literami pojawiają się tuż obok ich małych odpowiedników, a litery akcentowane znajdują się w pobliżu odpowiadającej im litery nieakcentowanej.

Porównanie porządkowe porównuje ściśle wartości liczbowe, zatrzymując się na pierwszej różnicy. To sortuje wielkie litery całkowicie oddzielone od małych liter (i litery akcentowane prawdopodobnie oddzielne od tych), więc wielkie litery nie posortowałyby nigdzie w pobliżu ich małych odpowiedników.

InvariantCulture również uważa, że ​​wielkie litery są większe niż małe litery, podczas gdy Ordinal uważa, że ​​wielkie litery są mniejsze niż małe litery (pozostałość ASCII z dawnych czasów, zanim komputer miał małe litery, wielkie litery były przydzielane jako pierwsze, a zatem miały niższe wartości niż małe litery dodane później).

Na przykład według Ordinal: "0" < "9" < "A" < "Ab" < "Z" < "a" < "aB" < "ab" < "z" < "Á" < "Áb" < "á" < "áb"

I przez InvariantCulture: "0" < "9" < "a" < "A" < "á" < "Á" < "ab" < "aB" < "Ab" < "áb" < "Áb" < "z" < "Z"

Chociaż pytanie dotyczy równości , dla szybkiego wizualnego odniesienia, tutaj kolejność niektórych ciągów posortowanych za pomocą kilku kultur ilustrujących niektóre z tych dziwactw.

Ordinal          0 9 A Ab a aB aa ab ss Ä Äb ß ä äb ぁ あ ァ ア 亜 Ａ
IgnoreCase       0 9 a A aa ab Ab aB ss ä Ä äb Äb ß ぁ あ ァ ア 亜 Ａ
--------------------------------------------------------------------
InvariantCulture 0 9 a A Ａ ä Ä aa ab aB Ab äb Äb ss ß ァ ぁ ア あ 亜
IgnoreCase       0 9 A a Ａ Ä ä aa Ab aB ab Äb äb ß ss ァ ぁ ア あ 亜
--------------------------------------------------------------------
da-DK            0 9 a A Ａ ab aB Ab ss ß ä Ä äb Äb aa ァ ぁ ア あ 亜
IgnoreCase       0 9 A a Ａ Ab aB ab ß ss Ä ä Äb äb aa ァ ぁ ア あ 亜
--------------------------------------------------------------------
de-DE            0 9 a A Ａ ä Ä aa ab aB Ab äb Äb ß ss ァ ぁ ア あ 亜
IgnoreCase       0 9 A a Ａ Ä ä aa Ab aB ab Äb äb ss ß ァ ぁ ア あ 亜
--------------------------------------------------------------------
en-US            0 9 a A Ａ ä Ä aa ab aB Ab äb Äb ß ss ァ ぁ ア あ 亜
IgnoreCase       0 9 A a Ａ Ä ä aa Ab aB ab Äb äb ss ß ァ ぁ ア あ 亜
--------------------------------------------------------------------
ja-JP            0 9 a A Ａ ä Ä aa ab aB Ab äb Äb ß ss ァ ぁ ア あ 亜
IgnoreCase       0 9 A a Ａ Ä ä aa Ab aB ab Äb äb ss ß ァ ぁ ア あ 亜

Obserwacje:

• de-DE, ja-JPi en-USposortuj w ten sam sposób
• Invarianttylko sortuje ssi ßinaczej niż powyższe trzy kultury
• da-DK sortuje się zupełnie inaczej
• te IgnoreCasesprawy flag dla wszystkich badanych kultur

Kod użyty do wygenerowania powyższej tabeli:

var l = new List<string>
    { "0", "9", "A", "Ab", "a", "aB", "aa", "ab", "ss", "ß",
      "Ä", "Äb", "ä", "äb", "あ", "ぁ", "ア", "ァ", "Ａ", "亜" };

foreach (var comparer in new[]
{
    StringComparer.Ordinal,
    StringComparer.OrdinalIgnoreCase,
    StringComparer.InvariantCulture,
    StringComparer.InvariantCultureIgnoreCase,
    StringComparer.Create(new CultureInfo("da-DK"), false),
    StringComparer.Create(new CultureInfo("da-DK"), true),
    StringComparer.Create(new CultureInfo("de-DE"), false),
    StringComparer.Create(new CultureInfo("de-DE"), true),
    StringComparer.Create(new CultureInfo("en-US"), false),
    StringComparer.Create(new CultureInfo("en-US"), true),
    StringComparer.Create(new CultureInfo("ja-JP"), false),
    StringComparer.Create(new CultureInfo("ja-JP"), true),
})
{
    l.Sort(comparer);
    Console.WriteLine(string.Join(" ", l));
}

Niezmiennik jest odpowiednim językowo rodzajem porównania.
Porządek jest binarnym rodzajem porównania. (szybciej)
Patrz http://www.siao2.com/2004/12/29/344136.aspx

Oto przykład, w którym porównanie równości łańcucha przy użyciu InvariantCultureIgnoreCase i OrdinalIgnoreCase nie da takich samych wyników:

string str = "\xC4"; //A with umlaut, Ä
string A = str.Normalize(NormalizationForm.FormC);
//Length is 1, this will contain the single A with umlaut character (Ä)
string B = str.Normalize(NormalizationForm.FormD);
//Length is 2, this will contain an uppercase A followed by an umlaut combining character
bool equals1 = A.Equals(B, StringComparison.OrdinalIgnoreCase);
bool equals2 = A.Equals(B, StringComparison.InvariantCultureIgnoreCase);

Jeśli to uruchomisz, equals1 będzie fałszywe, a equals2 będzie prawdziwe.

Nie trzeba używać fantazyjnych znaków Unicode, aby pokazać różnicę. Oto jeden prosty przykład, który odkryłem dzisiaj, który jest zaskakujący, składający się wyłącznie z znaków ASCII.

Zgodnie z tabelą ASCII 0(0x48) jest mniejsze niż _(0x95) w porównaniu ze zwykłym. InvariantCulture powiedziałoby coś przeciwnego (kod PowerShell poniżej):

PS> [System.StringComparer]::Ordinal.Compare("_", "0")
47
PS> [System.StringComparer]::InvariantCulture.Compare("_", "0")
-1

Zawsze staraj się używać InvariantCulture w tych metodach łańcuchowych, które akceptują to jako przeciążenie. Korzystając z InvariantCulture jesteś po bezpiecznej stronie. Wielu programistów .NET może nie korzystać z tej funkcji, ale jeśli twoje oprogramowanie będzie używane przez różne kultury, InvariantCulture jest niezwykle przydatną funkcją.