Diferença entre InvariantCulture e comparação de cadeias ordinais

Ao comparar duas seqüências de caracteres em c # para igualdade, qual é a diferença entre comparação entre InvariantCulture e Ordinal?

InvariantCulture

Usa um conjunto "padrão" de ordenação de caracteres (a, b, c, ... etc.). Isso contrasta com algumas localidades específicas, que podem classificar caracteres em diferentes ordens ('a-with-aguda' pode ser antes ou depois de 'a', dependendo da localidade e assim por diante).

Ordinal

Por outro lado, analisa puramente os valores dos bytes brutos que representam o caractere.

Há um ótimo exemplo em http://msdn.microsoft.com/en-us/library/e6883c06.aspx que mostra os resultados dos vários valores de StringComparison. No final, ele mostra (trecho):

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)

Você pode ver que, onde InvariantCulture gera (U + 0069, U + 0049, U + 00131), Ordinal produz (U + 0049, U + 0069, U + 00131).

Importa, por exemplo - existe uma coisa chamada expansão de personagem

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

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

Com InvariantCultureo caractere ß é expandido para ss.

Apontando para as práticas recomendadas para usar seqüências de caracteres no .NET Framework :

• Use StringComparison.Ordinalou StringComparison.OrdinalIgnoreCasepara comparações como seu padrão seguro para correspondência de sequência independente de cultura.
• Use comparações com StringComparison.Ordinalou StringComparison.OrdinalIgnoreCasepara obter melhor desempenho.
• Use os valores não-linguísticos StringComparison.Ordinalou em StringComparison.OrdinalIgnoreCasevez das operações de cadeia de caracteres com base em CultureInfo.InvariantCulturequando a comparação for linguisticamente irrelevante (simbólica, por exemplo).

E finalmente:

• Não use operações de string baseadas StringComparison.InvariantCulturena maioria dos casos . Uma das poucas exceções é quando você persiste em dados lingüisticamente significativos, mas culturalmente agnósticos.

Outra diferença útil (em inglês, onde os acentos são incomuns) é que uma comparação da InvariantCulture compara as seqüências inteiras primeiro sem distinção entre maiúsculas e minúsculas e, em seguida, se necessário (e solicitado) distingue por maiúsculas e minúsculas depois de comparar primeiro apenas nas letras distintas. (Você também pode fazer uma comparação sem distinção entre maiúsculas e minúsculas, é claro, o que não fará distinção entre maiúsculas e minúsculas.) Corrigido:As letras acentuadas são consideradas outro sabor das mesmas letras e a cadeia de caracteres é comparada primeiro, ignorando os acentos e depois contabilizando-os se todas as letras gerais corresponderem (da mesma forma que em maiúsculas e minúsculas, exceto que, no final, não são ignoradas em uma comparação que não diferencia maiúsculas de minúsculas). Isso agrupa versões acentuadas da mesma palavra, próximas umas das outras, em vez de se separarem completamente na primeira diferença de sotaque. Essa é a ordem de classificação que você normalmente encontraria em um dicionário, com palavras em maiúsculas aparecendo ao lado de seus equivalentes em minúsculas e letras acentuadas próximas à letra não acentuada correspondente.

Uma comparação ordinal compara estritamente os valores numéricos dos caracteres, parando na primeira diferença. Isso classifica as letras maiúsculas completamente separadas das letras minúsculas (e as letras acentuadas provavelmente se separam daquelas), para que as palavras maiúsculas não se aproximem dos equivalentes em minúsculas.

InvariantCulture também considera maiúsculas maiúsculas e minúsculas, enquanto Ordinal considera maiúsculas minúsculas (uma recuperação de ASCII dos velhos tempos antes dos computadores terem letras minúsculas, as letras maiúsculas eram alocadas primeiro e, portanto, tinham valores inferiores às letras minúsculas adicionado mais tarde).

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

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

Embora a questão seja sobre igualdade , para referência visual rápida, aqui está a ordem de algumas sequências ordenadas usando algumas culturas que ilustram algumas das idiossincrasias por aí.

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

Observações:

• de-DE, ja-JPe en-USclassifique da mesma maneira
• Invariantapenas classifica sse ßdiferentemente das três culturas acima
• da-DK classifica de maneira bem diferente
• a IgnoreCasebandeira é importante para todas as culturas incluídas na amostra

O código usado para gerar a tabela acima:

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 é um tipo de comparação linguisticamente apropriado.
Ordinal é um tipo binário de comparação. (mais rápido)
Consulte http://www.siao2.com/2004/12/29/344136.aspx

Aqui está um exemplo em que a comparação de igualdade de string usando InvariantCultureIgnoreCase e OrdinalIgnoreCase não fornecerá os mesmos 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);

Se você executar isso, igual a 1 será falso e igual a 2 será verdadeiro.

Não é necessário usar exemplos sofisticados de caracteres unicode para mostrar a diferença. Aqui está um exemplo simples que descobri hoje que é surpreendente, consistindo apenas em caracteres ASCII.

De acordo com a tabela ASCII, 0(0x48) é menor que _(0x95) quando comparado ordinalmente. InvariantCulture diria o contrário (código do PowerShell abaixo):

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

Sempre tente usar InvariantCulture nos métodos de string que o aceitam como sobrecarga. Usando InvariantCulture, você está em um lado seguro. Muitos programadores .NET podem não usar essa funcionalidade, mas se o seu software for usado por diferentes culturas, o InvariantCulture é um recurso extremamente útil.