Differenza tra InvariantCulture e confronto di stringhe ordinali

Quando si confrontano due stringhe in c # per l'uguaglianza, qual è la differenza tra InvariantCulture e Ordinal comparation?

InvariantCulture

Utilizza un set "standard" di ordini di caratteri (a, b, c, ... ecc.). Ciò è in contrasto con alcuni locali specifici, che possono ordinare i caratteri in diversi ordini ('a-with-acute' può essere prima o dopo 'a', a seconda delle impostazioni locali e così via).

Ordinale

D'altra parte, guarda puramente i valori dei byte grezzi che rappresentano il carattere.

C'è un ottimo esempio su http://msdn.microsoft.com/en-us/library/e6883c06.aspx che mostra i risultati dei vari valori StringComparison. Alla fine, mostra (estratto):

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)

Puoi vedere quello dove produce InvariantCulture (U + 0069, U + 0049, U + 00131), i rendimenti ordinali (U + 0049, U + 0069, U + 00131).

Ad esempio, importa: esiste una cosa chiamata espansione del personaggio

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

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

Con InvariantCultureil carattere ß viene espanso in ss.

Indicando le migliori pratiche per l'utilizzo delle stringhe in .NET Framework :

• Utilizzare StringComparison.Ordinalo StringComparison.OrdinalIgnoreCaseper i confronti come valore predefinito sicuro per la corrispondenza delle stringhe indipendenti dalla cultura.
• Utilizzare i confronti con StringComparison.Ordinalo StringComparison.OrdinalIgnoreCaseper prestazioni migliori.
• Utilizzare le operazioni non linguistiche StringComparison.Ordinalo StringComparison.OrdinalIgnoreCasevalori anziché le stringhe in base a CultureInfo.InvariantCulturequando il confronto è linguisticamente irrilevante (simbolico, ad esempio).

E infine:

• StringComparison.InvariantCultureNella maggior parte dei casi non utilizzare le operazioni di stringa basate su . Una delle poche eccezioni è quando si persistono dati linguisticamente significativi ma culturalmente agnostici.

Un'altra utile differenza (in inglese in cui gli accenti sono rari) è che un confronto InvariantCulture confronta prima le stringhe senza distinzione tra maiuscole e minuscole, quindi, se necessario (e richiesto), distingue per caso dopo aver prima confrontato solo su lettere distinte. (Puoi anche fare un confronto senza distinzione tra maiuscole e minuscole, ovviamente, che non si distingue per caso.) Corretto:Le lettere accentate sono considerate come un altro sapore delle stesse lettere e la stringa viene confrontata prima ignorando gli accenti e quindi calcolandoli se le lettere generali corrispondono tutte (come nel caso diverso, tranne che alla fine non vengono ignorate in un confronto senza distinzione tra maiuscole e minuscole). Questo raggruppa le versioni accentate della parola altrimenti identica l'una vicino all'altra invece di separarle completamente alla prima differenza di accento. Questo è il tipo di ordinamento che potresti trovare in un dizionario, con le parole in maiuscolo che appaiono accanto ai loro equivalenti minuscoli e le lettere accentate che si trovano vicino alla corrispondente lettera non accentata.

Un confronto ordinale confronta rigorosamente i valori dei caratteri numerici, fermandosi alla prima differenza. Questo ordina le lettere maiuscole completamente separate dalle lettere minuscole (e le lettere accentate presumibilmente separate da quelle), quindi le parole maiuscole non si collocano da nessuna parte vicino ai loro equivalenti minuscoli.

InvariantCulture considera anche le maiuscole più grandi delle lettere minuscole, mentre Ordinale considera le maiuscole meno che minuscole (un blocco di ASCII dai vecchi tempi prima che i computer avessero lettere minuscole, le lettere maiuscole venivano allocate per prime e quindi avevano valori più bassi delle lettere minuscole aggiunto in seguito).

Ad esempio, da Ordinal: "0" < "9" < "A" < "Ab" < "Z" < "a" < "aB" < "ab" < "z" < "Á" < "Áb" < "á" < "áb"

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

Sebbene la domanda riguardi l' uguaglianza , per un rapido riferimento visivo, qui l'ordine di alcune stringhe è stato ordinato usando un paio di culture che illustrano alcune delle idiosincrasie là fuori.

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

osservazioni:

• de-DE, ja-JPe en-USordina allo stesso modo
• Invariantsolo una specie sse in modo ßdiverso dalle tre culture precedenti
• da-DK ordina in modo abbastanza diverso
• la IgnoreCasebandiera è importante per tutte le culture campionate

Il codice utilizzato per generare la tabella sopra:

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 è un tipo di confronto linguisticamente appropriato.
Ordinale è un tipo binario di confronto. (più veloce)
Vedi http://www.siao2.com/2004/12/29/344136.aspx

Ecco un esempio in cui il confronto dell'uguaglianza delle stringhe usando InvariantCultureIgnoreCase e OrdinalIgnoreCase non darà gli stessi risultati:

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 lo esegui, equals1 sarà falso e equals2 sarà vero.

Non c'è bisogno di usare fantasiosi esempi di caratteri Unicode per mostrare la differenza. Ecco un semplice esempio che ho scoperto oggi che è sorprendente, costituito solo da caratteri ASCII.

Secondo la tabella ASCII, 0(0x48) è inferiore a _(0x95) se confrontato ordinariamente. InvariantCulture direbbe il contrario (codice PowerShell di seguito):

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

Cerca sempre di utilizzare InvariantCulture in quei metodi stringa che lo accettano come sovraccarico. Usando InvariantCulture sei al sicuro. Molti programmatori .NET potrebbero non utilizzare questa funzionalità ma se il tuo software verrà utilizzato da culture diverse, InvariantCulture è una funzionalità estremamente utile.