Diferencia entre InvariantCulture y comparación de cadenas ordinales

Al comparar dos cadenas en c # para la igualdad, ¿cuál es la diferencia entre InvariantCulture y la comparación ordinal?

Cultura Invariante

Utiliza un conjunto "estándar" de ordenamiento de caracteres (a, b, c, ... etc.). Esto contrasta con algunas configuraciones regionales específicas, que pueden ordenar los caracteres en diferentes órdenes ('a-with-acute' puede estar antes o después de 'a', dependiendo de la configuración regional, y así sucesivamente).

Ordinal

Por otro lado, analiza únicamente los valores de los bytes sin procesar que representan el carácter.

Hay una gran muestra en http://msdn.microsoft.com/en-us/library/e6883c06.aspx que muestra los resultados de los distintos valores de StringComparison. Todo el camino al final, muestra (extracto):

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)

Puede ver que donde InvariantCulture rinde (U + 0069, U + 0049, U + 00131), Ordinal rinde (U + 0049, U + 0069, U + 00131).

Sí importa, por ejemplo: hay una cosa llamada expansión de personaje

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

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

Con InvariantCultureel carácter ß se expande a ss.

Señalando las mejores prácticas para usar cadenas en .NET Framework :

• Use StringComparison.Ordinalo StringComparison.OrdinalIgnoreCasepara comparaciones como su valor predeterminado seguro para la coincidencia de cadenas independiente de la cultura.
• Use comparaciones con StringComparison.Ordinalo StringComparison.OrdinalIgnoreCasepara un mejor rendimiento.
• Utilice los valores no lingüísticos StringComparison.Ordinalo en StringComparison.OrdinalIgnoreCaselugar de las operaciones de cadena en función de CultureInfo.InvariantCulturecuándo la comparación es lingüísticamente irrelevante (simbólica, por ejemplo).

Y finalmente:

• No utilice operaciones de cadena basadas StringComparison.InvariantCultureen la mayoría de los casos . Una de las pocas excepciones es cuando persiste datos lingüísticamente significativos pero culturalmente agnósticos.

Otra diferencia útil (en inglés, donde los acentos son poco comunes) es que una comparación de InvariantCulture compara las cadenas completas por mayúsculas y minúsculas primero, y luego si es necesario (y solicitado) distingue por mayúsculas y minúsculas después de primero comparar solo las letras distintas. (También puede hacer una comparación entre mayúsculas y minúsculas, por supuesto, que no distinguirá entre mayúsculas y minúsculas). Corregido:Las letras acentuadas se consideran otro sabor de las mismas letras y la cadena se compara primero ignorando los acentos y luego contabilizándolos si todas las letras generales coinciden (al igual que con mayúsculas y minúsculas, excepto que finalmente no se ignoran en una comparación que no distingue entre mayúsculas y minúsculas). Esto agrupa versiones acentuadas de la misma palabra, por lo demás, cercanas entre sí en lugar de estar completamente separadas en la primera diferencia de acento. Este es el orden de clasificación que normalmente encontraría en un diccionario, con palabras en mayúscula que aparecen justo al lado de sus equivalentes en minúsculas, y las letras acentuadas están cerca de la letra sin acento correspondiente.

Una comparación ordinal se compara estrictamente con los valores de caracteres numéricos, deteniéndose en la primera diferencia. Esto clasifica las letras en mayúscula completamente separadas de las letras minúsculas (y las letras acentuadas presumiblemente separadas de esas), por lo que las palabras en mayúscula no se clasificarían cerca de sus equivalentes en minúsculas.

InvariantCulture también considera que las mayúsculas son más grandes que las minúsculas, mientras que Ordinal considera que las mayúsculas son menos que minúsculas (un remanente de ASCII de los viejos tiempos antes de que las computadoras tuvieran letras minúsculas, las letras mayúsculas se asignaron primero y por lo tanto tenían valores más bajos que las minúsculas añadido más tarde).

Por ejemplo, por Ordinal: "0" < "9" < "A" < "Ab" < "Z" < "a" < "aB" < "ab" < "z" < "Á" < "Áb" < "á" < "áb"

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

Aunque la pregunta es sobre igualdad , para una referencia visual rápida, aquí el orden de algunas cadenas ordenadas usando un par de culturas que ilustran algunas de las idiosincrasias existentes.

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

Observaciones:

• de-DE, ja-JPy en-USordenar de la misma manera
• Invariantsolo clasifica ssy de manera ßdiferente a las tres culturas anteriores
• da-DK se clasifica de manera bastante diferente
• la IgnoreCasebandera es importante para todas las culturas muestreadas

El código utilizado para generar la tabla anterior:

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 es un tipo de comparación lingüísticamente apropiado.
El ordinal es un tipo binario de comparación. (más rápido)
Ver http://www.siao2.com/2004/12/29/344136.aspx

Aquí hay un ejemplo donde la comparación de igualdad de cadenas usando InvariantCultureIgnoreCase y OrdinalIgnoreCase no dará los mismos resultados:

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 ejecuta esto, equals1 será falso y equals2 será verdadero.

No es necesario usar extractos de caracteres unicode para mostrar la diferencia. Aquí hay un ejemplo simple que descubrí hoy que es sorprendente, que consiste solo en caracteres ASCII.

De acuerdo con la tabla ASCII, 0(0x48) es menor que _(0x95) en comparación ordinalmente. InvariantCulture diría lo contrario (código de PowerShell a continuación):

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

Siempre trate de usar InvariantCulture en esos métodos de cadena que lo aceptan como sobrecarga. Al usar InvariantCulture estás en un lado seguro. Muchos programadores .NET pueden no usar esta funcionalidad, pero si su software será utilizado por diferentes culturas, InvariantCulture es una característica extremadamente útil.