Perbedaan antara InvariantCulture dan perbandingan string Ordinal

Ketika membandingkan dua string dalam c # untuk kesetaraan, apa perbedaan antara InvariantCulture dan perbandingan Ordinal?

Budaya Invariant

Menggunakan seperangkat urutan karakter "standar" (a, b, c, ... dll). Ini berbeda dengan beberapa lokal tertentu, yang dapat mengurutkan karakter dalam urutan yang berbeda ('a-dengan-akut' mungkin sebelum atau setelah 'a', tergantung pada lokal, dan sebagainya).

Urut

Di sisi lain, terlihat murni pada nilai byte mentah yang mewakili karakter.

Ada contoh yang bagus di http://msdn.microsoft.com/en-us/library/e6883c06.aspx yang menunjukkan hasil dari berbagai nilai StringComparison. Sepanjang jalan, itu menunjukkan (dikutip):

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)

Anda dapat melihat bahwa di mana InvariantCulture menghasilkan (U + 0069, U + 0049, U + 00131), hasil ordinal (U + 0049, U + 0069, U + 00131).

Itu penting, misalnya - ada hal yang disebut ekspansi karakter

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

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

Dengan InvariantCulturekarakter ß diperluas ke ss.

Menunjuk ke Praktik Terbaik untuk Menggunakan String di .NET Framework :

• Gunakan StringComparison.Ordinalatau StringComparison.OrdinalIgnoreCaseuntuk perbandingan sebagai standar aman Anda untuk pencocokan string agnostik kultur.
• Gunakan perbandingan dengan StringComparison.Ordinalatau StringComparison.OrdinalIgnoreCaseuntuk kinerja yang lebih baik.
• Gunakan nilai-nilai non-linguistik StringComparison.Ordinalatau StringComparison.OrdinalIgnoreCasebukannya operasi string yang didasarkan pada CultureInfo.InvariantCultureketika perbandingan tidak relevan secara linguistik (simbolis, misalnya).

Dan akhirnya:

• Jangan gunakan operasi string berdasarkan pada StringComparison.InvariantCulturekebanyakan kasus . Salah satu dari sedikit pengecualian adalah ketika Anda mempertahankan data agnostik yang secara linguistik bermakna tetapi secara budaya.

Perbedaan praktis lainnya (dalam bahasa Inggris di mana aksen tidak umum) adalah bahwa perbandingan InvariantCulture membandingkan seluruh string dengan case-insensitive pertama, dan kemudian jika perlu (dan diminta) membedakan dengan case setelah terlebih dahulu membandingkan hanya pada huruf yang berbeda. (Anda juga dapat melakukan perbandingan case-insensitive, tentu saja, yang tidak akan membedakan dengan case.) Dikoreksi:Huruf beraksen dianggap sebagai citarasa lain dari huruf-huruf yang sama dan string dibandingkan pertama kali mengabaikan aksen dan kemudian memperhitungkannya jika huruf-huruf umum semuanya cocok (seperti halnya case yang berbeda kecuali pada akhirnya tidak diabaikan dalam perbandingan case-insensitive). Grup-grup ini mengaksen versi-versi kata yang sebaliknya dekat satu sama lain, bukannya sepenuhnya terpisah pada perbedaan aksen pertama. Ini adalah urutan yang biasanya Anda temukan dalam kamus, dengan kata-kata berhuruf besar muncul tepat di sebelah padanan huruf kecilnya, dan huruf beraksen berada di dekat huruf yang tidak beraksen.

Perbandingan ordinal membandingkan secara ketat pada nilai karakter numerik, berhenti pada perbedaan pertama. Jenis huruf besar ini benar-benar terpisah dari huruf kecil (dan huruf beraksen agaknya terpisah dari huruf kecil), jadi kata-kata dengan huruf besar tidak akan menyamai tempat yang dekat dengan huruf kecilnya.

InvariantCulture juga menganggap huruf kapital lebih besar daripada huruf kecil, sedangkan Ordinal menganggap huruf kapital lebih kecil dari huruf kecil (peninggalan ASCII dari masa lalu sebelum komputer memiliki huruf kecil, huruf besar dialokasikan terlebih dahulu dan dengan demikian memiliki nilai lebih rendah dari huruf kecil ditambahkan nanti).

Misalnya, menurut Ordinal: "0" < "9" < "A" < "Ab" < "Z" < "a" < "aB" < "ab" < "z" < "Á" < "Áb" < "á" < "áb"

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

Meskipun pertanyaannya adalah tentang kesetaraan , untuk referensi visual cepat, di sini urutan beberapa string diurutkan menggunakan beberapa budaya yang menggambarkan beberapa keanehan di luar sana.

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

Pengamatan:

• de-DE,, ja-JPdan en-USurutkan dengan cara yang sama
• Invarianthanya macam ssdan ßberbeda dari tiga budaya di atas
• da-DK agak berbeda
• yang IgnoreCasehal bendera untuk semua budaya sampel

Kode yang digunakan untuk menghasilkan tabel di atas:

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

Invarian adalah jenis perbandingan yang sesuai secara linguistik.
Ordinal adalah jenis perbandingan biner. (lebih cepat)
Lihat http://www.siao2.com/2004/12/29/344136.aspx

Berikut adalah contoh di mana perbandingan kesetaraan string menggunakan InvariantCultureIgnoreCase dan OrdinalIgnoreCase tidak akan memberikan hasil yang sama:

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

Jika Anda menjalankan ini, equals1 akan salah, dan equals2 akan benar.

Tidak perlu menggunakan exmaples unicode char yang mewah untuk menunjukkan perbedaannya. Inilah satu contoh sederhana yang saya temukan hari ini yang mengejutkan, hanya terdiri dari karakter ASCII.

Menurut tabel ASCII, 0(0x48) lebih kecil dari _(0x95) bila dibandingkan secara ordinal. InvariantCulture akan mengatakan sebaliknya (kode PowerShell di bawah):

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

Selalu mencoba menggunakan InvariantCulture dalam metode string yang menerimanya sebagai kelebihan beban. Dengan menggunakan InvariantCulture Anda berada di sisi yang aman. Banyak pemrogram .NET mungkin tidak menggunakan fungsi ini tetapi jika perangkat lunak Anda akan digunakan oleh budaya yang berbeda, InvariantCulture adalah fitur yang sangat berguna.