Разница между InvariantCulture и порядком сравнения строк

При сравнении двух строк в c # на равенство, в чем разница между InvariantCulture и Порядковым сравнением?

InvariantCulture

Использует «стандартный» набор порядков символов (a, b, c, ... и т. Д.). Это отличается от некоторых конкретных локалей, которые могут сортировать символы в разных порядках («с острым» может быть до или после «а», в зависимости от локали и т. Д.).

порядковый

С другой стороны, смотрит чисто на значения необработанных байтов, которые представляют символ.

На http://msdn.microsoft.com/en-us/library/e6883c06.aspx есть отличный пример , показывающий результаты различных значений StringComparison. Весь путь в конце показывает (отрывок):

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)

Вы можете видеть, что там, где доходность InvariantCulture (U + 0069, U + 0049, U + 00131), порядковая доходность (U + 0049, U + 0069, U + 00131).

Это имеет значение, например, есть такая вещь, как расширение персонажа

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

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

С InvariantCultureсимволом ß расширяется до ss.

Указание на рекомендации по использованию строк в .NET Framework :

• Используйте StringComparison.OrdinalилиStringComparison.OrdinalIgnoreCase для сравнения в качестве безопасного значения по умолчанию для сопоставления строк, не зависящего от культуры.
• Используйте сравнения с StringComparison.OrdinalилиStringComparison.OrdinalIgnoreCase для лучшей производительности.
• Используйте неязыковые StringComparison.Ordinalили StringComparison.OrdinalIgnoreCaseзначения вместо строковых операций в зависимости от того, CultureInfo.InvariantCultureкогда сравнение не имеет лингвистического значения (например, символическое).

И наконец:

• Не используйте строковые операции, основанные на StringComparison.InvariantCultureбольшинстве случаев . Одно из немногих исключений - когда вы сохраняете лингвистически значимые, но культурно-независимые данные.

Еще одно удобное отличие (на английском языке, где акценты встречаются редко) заключается в том, что сравнение InvariantCulture сначала сравнивает целые строки без учета регистра, а затем, если необходимо (и запрашивается), различает регистр после первого сравнения только по разным буквам. (Конечно, вы также можете сделать сравнение без учета регистра, которое не будет различаться в каждом конкретном случае.) Исправлено:Акцентированные буквы считаются другой разновидностью тех же букв, и строка сравнивается сначала без учета акцентов, а затем учитывает их, если все общие буквы совпадают (во многом как с другим регистром, за исключением того, что в конечном итоге не игнорируется при сравнении без учета регистра). Эта группа акцентирует версии одного и того же слова рядом друг с другом, а не полностью разделяется при первой разнице в акценте. Это порядок сортировки, который вы обычно находите в словаре, где заглавные слова появляются рядом с их строчными эквивалентами, а акцентированные буквы - рядом с соответствующей безударной буквой.

Порядковое сравнение строго сравнивает числовые значения символов, останавливаясь на первом разнице. Это сортирует заглавные буквы полностью отдельно от строчных букв (и ударные буквы, по-видимому, отдельно от них), поэтому слова с заглавными буквами не сортируются ни в какое сравнение с их строчными эквивалентами.

InvariantCulture также считает, что заглавные буквы больше, чем строчные, в то время как Ordinal считает заглавные буквы меньше строчных (пережиток ASCII со старых времен, когда компьютеры имели строчные буквы, прописные буквы были выделены первыми и, следовательно, имели более низкие значения, чем строчные буквы добавлю позже).

Например, по ординалу: "0" < "9" < "A" < "Ab" < "Z" < "a" < "aB" < "ab" < "z" < "Á" < "Áb" < "á" < "áb"

И по InvariantCulture: "0" < "9" < "a" < "A" < "á" < "Á" < "ab" < "aB" < "Ab" < "áb" < "Áb" < "z" < "Z"

Хотя вопрос заключается в равенстве , для быстрой визуальной ссылки, здесь порядок некоторых строк отсортирован с использованием нескольких культур, иллюстрирующих некоторые специфические особенности.

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

Замечания:

• de-DE, ja-JPИ en-USвроде так же , как
• Invariantтолько виды ssи в ßотличие от вышеупомянутых трех культур
• da-DK сортирует совсем по другому
• на IgnoreCaseвопросы флаг для всех отобранных культур

Код, использованный для генерации таблицы выше:

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

Инвариант - это лингвистически подходящий тип сравнения.
Порядковый номер - это двоичный тип сравнения. (быстрее)
См. http://www.siao2.com/2004/12/29/344136.aspx

Вот пример, где сравнение равенства строк с использованием InvariantCultureIgnoreCase и OrdinalIgnoreCase не даст одинаковых результатов:

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

Если вы запустите это, equals1 будет false, а equals2 будет true.

Не нужно использовать причудливые примеры символов Unicode, чтобы показать разницу. Вот один простой пример, который я обнаружил сегодня, который удивителен и состоит только из символов ASCII.

Согласно таблице ASCII, 0(0x48) меньше, чем _(0x95) при обычном сравнении. InvariantCulture сказал бы обратное (код PowerShell ниже):

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

Всегда старайтесь использовать InvariantCulture в тех строковых методах, которые принимают его как перегрузку. Используя InvariantCulture вы на безопасной стороне. Многие программисты .NET могут не использовать эту функциональность, но если ваше программное обеспечение будет использоваться разными культурами, InvariantCulture - чрезвычайно удобная функция.