Почему строки в .net по умолчанию чувствительны к регистру?

Извините за банальный ответ, но так оно и есть :)

На базовом уровне строки представлены в виде списка символов, где «а» отличается от «А», поэтому это, вероятно, самое простое представление \ соглашение в целом. В вашем случае, вероятно, будет справедливо сказать, что большинство сравнений нечувствительны к регистру, но я думаю, что другая сторона аргумента верна, по крайней мере, в такой же степени, и соглашение было принято.

Я полагаю, что использование некоторых вспомогательных методов\классов несколько облегчит вашу боль.

Потому что существуют разные виды нечувствительного сопоставления, и неясно, какой из них вам нужен. Вот три наиболее распространенных режима:

StringComparison.OrdinalIgnoreCase
StringComparison.InvariantCultureIgnoreCase
StringComparison.CurrentCultureIgnoreCase

У них совершенно разные варианты использования. Вы, вероятно, этого не замечали, потому что ежедневно имеете дело с ASCII. Пользователи в других регионах видят больше различий.

Потому что нечувствительность к регистру неэффективна и потому что она работает, даже если вы этого не хотите.

Поставщики должны конкурировать на основе производительности, и по этой причине вариант по умолчанию, как правило, является тем, который работает лучше всего. В лучшем случае нечувствительность к регистру требует приведения обеих строк к общему регистру перед сравнением. В худшем случае, в зависимости от локали, путь кода может быть в два раза длиннее. Если поставщик по умолчанию выберет менее производительную версию, конкуренты выберут наихудшие сценарии для сравнения.

Поскольку чувствительность к регистру не работает при некоторых поисковых запросах, вы вынуждены учитывать это в своем коде. Это заставляет принять сознательное решение. Напротив, нечувствительность к регистру работает даже в тех случаях, когда вы этого не хотите. Вместо того, чтобы заставлять вас принимать решение, он создает сценарий, в котором вы можете игнорировать его в ущерб себе. При выборе архитектуры поставщики склонны выбирать вариант, который приводит к меньшему количеству дефектов — в данном случае это чувствительность к регистру.

Сравнение строк в .Net чувствительно к регистру, поскольку строки (и отдельные символы) по своей природе чувствительны к регистру.

Символ «a» хранится внутри с другим значением ASCII или Unicode как «A». Говорить, что «а» — это то же самое, что «А», «неправильно».

Это различие становится критическим при сравнении значений на языках, отличных от английского, при использовании таких алгоритмов, как хеш-таблицы, или при использовании множества алгоритмов шифрования/дешифрования.

Мои два цента: сравнение с учетом регистра используется по умолчанию, потому что оно правильное.

В VB.NET можно установить «параметр сравнения» с текстом, чтобы он работал без учета регистра, но я настоятельно не рекомендую это делать. Мне больше всего нравится использовать метод string.toLower(), когда мне нужно нечувствительно сравнить и прочитать версию текста в нижнем регистре.

Почему? Потому что, как еще вы могли бы сравнить, когда чувствительность к регистру имеет значение, как это было бы в некоторых приложениях?

Вы не можете изменить поведение существующих классов. System.String, который определен в mscorelib/system.core, переопределяет == и определяет равенство с учетом регистра.

Все, что вы можете сделать, это добавить метод расширения к строке и реализовать нечувствительный к регистру:

public static class StringEqualityExtension
{
    public static bool StringEquals(this string value, string other)
    {
       return value.ToLower()==other.ToLower();
    } 
}

// usage
string myString = "Some112";
string other = "sOME112";

bool equal = myString.StringEquals(myString);

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

Сопоставление примечаний без учета регистра тривиально просто. На самом деле метод equals для строки имеет перегруженную версию специально для указания способа сравнения.

Я знаю, что это некропостинг, но

Я пришел сюда в поисках решения той же проблемы. Сейчас прошло почти 5 лет... но я не против, так как это один из первых результатов поиска, и я думаю, что было бы лучше включить правильную информацию.

Согласно этой странице MSDN, вам просто нужно добавить 1 строку кода в ваш файл:

Option Compare Text

Если вы добавите приведенную выше строку в начало вашего ядра, вы скажете CLR переключиться с сравнения по умолчанию (Option Compare Binary) на сравнение без учета регистра.

Я не знаю, может ли это работать на С#.