Différence entre InvariantCulture et comparaison de chaînes ordinales

Lorsque vous comparez deux chaînes en c # pour l'égalité, quelle est la différence entre InvariantCulture et la comparaison ordinale?

InvariantCulture

Utilise un ensemble "standard" d'ordonnances de caractères (a, b, c, ... etc.). Cela contraste avec certains paramètres régionaux spécifiques, qui peuvent trier les caractères dans des ordres différents («a-with-aigu» peut être avant ou après «a», selon les paramètres régionaux, etc.).

Ordinal

D'un autre côté, regarde uniquement les valeurs des octets bruts qui représentent le caractère.

Il existe un excellent exemple à http://msdn.microsoft.com/en-us/library/e6883c06.aspx qui montre les résultats des différentes valeurs StringComparison. À la fin, cela montre (extrait):

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)

Vous pouvez voir que lorsque InvariantCulture donne (U + 0069, U + 0049, U + 00131), les rendements ordinaux (U + 0049, U + 0069, U + 00131).

Cela importe, par exemple - il y a une chose appelée expansion des personnages

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

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

Le InvariantCulturecaractère ß est étendu aux ss.

Pointant vers les meilleures pratiques pour l'utilisation de chaînes dans le .NET Framework :

• Utilisez StringComparison.Ordinalou StringComparison.OrdinalIgnoreCasepour les comparaisons comme valeur par défaut pour la correspondance de chaînes indépendante de la culture.
• Utilisez des comparaisons avec StringComparison.Ordinalou StringComparison.OrdinalIgnoreCasepour de meilleures performances.
• Utilisez les valeurs non linguistiques StringComparison.Ordinalou StringComparison.OrdinalIgnoreCaseau lieu d'opérations de chaîne en fonction du CultureInfo.InvariantCulturemoment où la comparaison n'est pas pertinente sur le plan linguistique (symbolique, par exemple).

Et enfin:

• N'utilisez pas d'opérations de chaîne basées sur StringComparison.InvariantCulturedans la plupart des cas . L'une des rares exceptions concerne les données persistantes sur le plan linguistique mais culturellement agnostiques.

Une autre différence pratique (en anglais où les accents sont rares) est qu'une comparaison InvariantCulture compare d'abord les chaînes entières en respectant la casse, puis si nécessaire (et demandé) distingue par cas après avoir d'abord comparé uniquement sur les lettres distinctes. (Vous pouvez également faire une comparaison insensible à la casse, bien sûr, qui ne distingue pas par cas.) Corrigé:Les lettres accentuées sont considérées comme une autre saveur des mêmes lettres et la chaîne est d'abord comparée en ignorant les accents, puis en les comptabilisant si les lettres générales correspondent toutes (tout comme avec une casse différente, mais pas finalement ignorée dans une comparaison insensible à la casse). Cela regroupe les versions accentuées du même mot autrement près les unes des autres au lieu d'être complètement séparées à la première différence d'accent. Il s'agit de l'ordre de tri que vous trouverez généralement dans un dictionnaire, avec des mots en majuscule apparaissant juste à côté de leurs équivalents en minuscules et des lettres accentuées proches de la lettre non accentuée correspondante.

Une comparaison ordinale compare strictement les valeurs des caractères numériques, s'arrêtant à la première différence. Cela trie les lettres majuscules complètement distinctes des lettres minuscules (et les lettres accentuées vraisemblablement distinctes de celles-ci), de sorte que les mots en majuscules ne seraient nulle part proches de leurs équivalents minuscules.

InvariantCulture considère également que les majuscules sont plus grandes que les minuscules, alors que Ordinal considère les majuscules moins que les minuscules (une trace d'ASCII de l'ancien temps avant que les ordinateurs aient des lettres minuscules, les lettres majuscules étaient allouées en premier et avaient donc des valeurs inférieures aux lettres minuscules). ajouté plus tard).

Par exemple, par Ordinal: "0" < "9" < "A" < "Ab" < "Z" < "a" < "aB" < "ab" < "z" < "Á" < "Áb" < "á" < "áb"

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

Bien que la question porte sur l' égalité , pour une référence visuelle rapide, voici l'ordre de certaines chaînes triées à l' aide de deux cultures illustrant certaines des idiosyncrasies là-bas.

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

Observations:

• de-DE, ja-JPEt en-USsorte de la même façon
• Invarianttrie seulement sset ßdifféremment des trois cultures ci-dessus
• da-DK trie très différemment
• le IgnoreCasedrapeau est important pour toutes les cultures échantillonnées

Le code utilisé pour générer le tableau ci-dessus:

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

Invariant est un type de comparaison linguistiquement approprié.
Ordinal est un type de comparaison binaire. (plus rapide)
Voir http://www.siao2.com/2004/12/29/344136.aspx

Voici un exemple où la comparaison d'égalité de chaîne utilisant InvariantCultureIgnoreCase et OrdinalIgnoreCase ne donnera pas les mêmes résultats:

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

Si vous exécutez ceci, equals1 sera faux et equals2 sera vrai.

Pas besoin d'utiliser des exemples de caractères unicode fantaisie pour montrer la différence. Voici un exemple simple que j'ai découvert aujourd'hui qui est surprenant, composé uniquement de caractères ASCII.

Selon le tableau ASCII, 0(0x48) est plus petit que _(0x95) en comparaison ordinaire. InvariantCulture dirait le contraire (code PowerShell ci-dessous):

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

Essayez toujours d'utiliser InvariantCulture dans les méthodes de chaîne qui l'acceptent comme surcharge. En utilisant InvariantCulture, vous êtes du bon côté. De nombreux programmeurs .NET peuvent ne pas utiliser cette fonctionnalité, mais si votre logiciel sera utilisé par différentes cultures, InvariantCulture est une fonctionnalité extrêmement pratique.