Почему в C # учитывается регистр?

C # чувствителен к регистру, потому что он следует за языками стиля C, которые все чувствительны к регистру. Это по памяти вот ссылка MSDN, которая у меня не работает. сейчас я не могу проверить.

Я также хотел бы отметить, что это очень правильный вариант использования:

public class Child
{
   private Person parent;
   public Person Parent
   {
      get { return parent;}
   }
}

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

Они, вероятно, думали, что «мы не хотим, чтобы люди использовали СМЕВАРИЯ в одном месте, а НЕКОТОРЫЕ - в другом.

Рассмотрим имена переменных в следующем псевдокоде:

class Foo extends Object { ... }
...
foo = new Foo();

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

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

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

Вот почему люди иногда так поступают, и это может иметь смысл:

Foo foo = new Foo();

Я делаю это постоянно, это очень полезно. Если вы подумаете об этом в более полезной ситуации, например:

Image image = Image.LoadFrom(path);

Иногда имеет смысл называть экземпляр так же, как имя класса, и единственный способ отличить их - это регистр. В C ++ чувствительность к регистру становится еще более полезной, но это уже другая история. Я могу уточнить, если вам интересно.

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

C # наследует чувствительность к регистру от C и Java, которую пытается имитировать, чтобы разработчикам было проще перейти на C #.

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

Вероятно, скопировано с C, C ++, Java и т. Д. Или может остаться таким же специально, чтобы оно было похоже на то, что есть на других языках.

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

РЕДАКТИРОВАТЬ:

Почему это можно считать плохим.

class SomeClass 
{
    private int someField;

    public int SomeField
    {
        get { return SomeField; } 
        // now we have recursion where its not wanted and its 
        // difficult for the eye to pick out and results in a
        // StackOverflowException.
    }
}

Добавление к частным полям префикса _ или m может облегчить обнаружение. Это не очень важно, и лично я все равно делаю именно то, что я только что сказал, плохо (так что подайте на меня в суд!).

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

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

Все современные языки используют чувствительность к регистру: в каких нет?

Как человек, который использовал BASIC в течение нескольких лет, я очень устал от разработчиков, использующих разные случаи для одной и той же переменной. На такие вещи очень утомительно смотреть, и они поощряют небрежное программирование. Если вы не можете позаботиться о правильном рассмотрении дела - что еще вам не стоит делать?

Из Руководства разработчика .NET Framework Правила использования заглавных букв, чувствительность к регистру:

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

Не думайте, что все языки программирования чувствительны к регистру. Они не. Имена не могут различаться только регистром.

Мое лучшее предположение относительно того, почему это чувствительно к регистру, было бы потому, что Unix чувствителен к регистру. Деннис Ричи, отец C, также был соавтором Unix, поэтому логично, что язык, который он написал, совпадал с окружающей средой, доступной в то время. C # только что унаследовал это от своего предка. Я думаю, что это было хорошее решение со стороны Microsoft, поскольку пути Windows не чувствительны к регистру.

Я предполагаю, что вы хотели бы увидеть такой код:

SomeField=28;
someField++;
somefield++;
SOMEFIELD++;

скомпилировано так, как если бы SomeField в любом варианте корпуса - это одна и та же переменная.

Лично я считаю это плохой идеей. Это поощряет лень и / или беспечность. Зачем правильно закрывать вещь, если это все равно не имеет значения? Ну, раз уж мы это делаем, может быть, компилятор должен разрешить орфографические ошибки, например SoemField++?

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

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