Unterschied zwischen InvariantCulture und Ordinal String Vergleich

Was ist der Unterschied zwischen InvariantCulture und Ordinalvergleich, wenn zwei Zeichenfolgen in c # auf Gleichheit verglichen werden?

InvariantCulture

Verwendet einen "Standard" -Satz von Zeichenreihenfolgen (a, b, c, ... usw.). Dies steht im Gegensatz zu einigen bestimmten Gebietsschemas, in denen Zeichen in unterschiedlicher Reihenfolge sortiert werden können ("a-mit-akut" kann je nach Gebietsschema vor oder nach "a" stehen usw.).

Ordinal

Betrachtet man dagegen nur die Werte der Rohbytes, die das Zeichen darstellen.

Unter http://msdn.microsoft.com/en-us/library/e6883c06.aspx finden Sie ein großartiges Beispiel , das die Ergebnisse der verschiedenen StringComparison-Werte zeigt. Am Ende zeigt es (Auszug):

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)

Sie können sehen, wo InvariantCulture ergibt (U + 0069, U + 0049, U + 00131), Ordnungserträge (U + 0049, U + 0069, U + 00131).

Es ist zum Beispiel wichtig - es gibt eine Sache, die als Charaktererweiterung bezeichnet wird

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

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

Mit InvariantCulturedem ß wird das Zeichen auf ss erweitert.

Verweisen auf bewährte Methoden für die Verwendung von Zeichenfolgen in .NET Framework :

• Verwenden Sie StringComparison.Ordinaloder StringComparison.OrdinalIgnoreCasefür Vergleiche als sicheren Standard für den kulturunabhängigen String-Abgleich.
• Verwenden Sie Vergleiche mit StringComparison.Ordinaloder StringComparison.OrdinalIgnoreCasefür eine bessere Leistung.
• Verwenden Sie nicht-sprachliche StringComparison.Ordinaloder StringComparison.OrdinalIgnoreCaseWerte anstelle von Zeichenfolgenoperationen, je nachdem, CultureInfo.InvariantCulturewann der Vergleich sprachlich irrelevant ist (z. B. symbolisch).

Und schlussendlich:

• Verwenden Sie StringComparison.InvariantCulturein den meisten Fällen keine Zeichenfolgenoperationen basierend auf . Eine der wenigen Ausnahmen ist, wenn Sie sprachlich bedeutsame, aber kulturell agnostische Daten beibehalten.

Ein weiterer praktischer Unterschied (auf Englisch, wo Akzente ungewöhnlich sind) besteht darin, dass bei einem InvariantCulture-Vergleich die gesamten Zeichenfolgen zuerst nach Groß- und Kleinschreibung verglichen werden und dann, falls erforderlich (und angefordert), nach Groß- und Kleinschreibung unterschieden wird, nachdem zuerst nur die einzelnen Buchstaben verglichen wurden. (Sie können natürlich auch einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung durchführen, bei dem nicht nach Groß- und Kleinschreibung unterschieden wird.) Korrigiert:Akzentuierte Buchstaben werden als eine andere Variante derselben Buchstaben betrachtet, und die Zeichenfolge wird verglichen, wobei zuerst Akzente ignoriert und dann berücksichtigt werden, wenn alle allgemeinen Buchstaben übereinstimmen (ähnlich wie bei unterschiedlichen Groß- und Kleinschreibung, außer dass sie bei einem Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung nicht letztendlich ignoriert werden). Diese Gruppe akzentuiert Versionen des ansonsten gleichen Wortes nahe beieinander, anstatt beim ersten Akzentunterschied vollständig getrennt zu sein. Dies ist die Sortierreihenfolge, die Sie normalerweise in einem Wörterbuch finden. Großgeschriebene Wörter werden direkt neben ihren Kleinbuchstaben angezeigt, und Buchstaben mit Akzent befinden sich in der Nähe des entsprechenden Buchstabens ohne Akzent.

Ein Ordnungsvergleich vergleicht streng die numerischen Zeichenwerte und endet bei der ersten Differenz. Dies sortiert großgeschriebene Buchstaben vollständig getrennt von den Kleinbuchstaben (und Akzentbuchstaben vermutlich getrennt von diesen), so dass großgeschriebene Wörter nicht annähernd ihre Kleinbuchstabenäquivalente sortieren würden.

InvariantCulture betrachtet Großbuchstaben auch als größer als Kleinbuchstaben, während Ordinal Großbuchstaben als kleiner als Kleinbuchstaben betrachtet (ein Überbleibsel von ASCII aus den alten Tagen, bevor Computer Kleinbuchstaben hatten, wurden die Großbuchstaben zuerst zugewiesen und hatten daher niedrigere Werte als die Kleinbuchstaben später hinzugefügt).

Zum Beispiel durch Ordinal: "0" < "9" < "A" < "Ab" < "Z" < "a" < "aB" < "ab" < "z" < "Á" < "Áb" < "á" < "áb"

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

Obwohl es sich um eine Frage der Gleichheit handelt , wird hier zur schnellen visuellen Bezugnahme die Reihenfolge einiger Zeichenfolgen anhand einiger Kulturen sortiert , um einige der Besonderheiten zu veranschaulichen.

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 ß ァ ぁ ア あ 亜

Beobachtungen:

• de-DE, ja-JPUnd en-USsortieren die gleiche Art und Weise
• Invariantnur sortiert ssund ßanders als die oben genannten drei Kulturen
• da-DK sortiert ganz anders
• Die IgnoreCaseFlagge ist für alle untersuchten Kulturen von Bedeutung

Der zum Generieren der obigen Tabelle verwendete Code:

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

Invariante ist eine sprachlich angemessene Art des Vergleichs.
Ordnungszahl ist ein binärer Vergleichstyp. (schneller)
Siehe http://www.siao2.com/2004/12/29/344136.aspx

Hier ist ein Beispiel, bei dem der Vergleich der Zeichenfolgengleichheit mit InvariantCultureIgnoreCase und OrdinalIgnoreCase nicht zu denselben Ergebnissen führt:

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

Wenn Sie dies ausführen, ist equals1 falsch und equals2 ist true.

Sie müssen keine ausgefallenen Unicode-Zeichenbeispiele verwenden, um den Unterschied zu zeigen. Hier ist ein einfaches Beispiel, das ich heute herausgefunden habe und das überraschend ist und nur aus ASCII-Zeichen besteht.

Gemäß der ASCII-Tabelle ist 0(0x48) im _normalen Vergleich kleiner als (0x95). InvariantCulture würde das Gegenteil sagen (PowerShell-Code unten):

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

Versuchen Sie immer, InvariantCulture in den Zeichenfolgenmethoden zu verwenden, die dies als Überladung akzeptieren. Mit InvariantCulture sind Sie auf der sicheren Seite. Viele .NET-Programmierer verwenden diese Funktionalität möglicherweise nicht. Wenn Ihre Software jedoch von verschiedenen Kulturen verwendet wird, ist InvariantCulture eine äußerst praktische Funktion.