Почему разработчики на C # открывают новые скобки? [закрыто]

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

public void MyFunction(string myArgument)
{
     //do stuff
}

if(myBoolean == true)
{
    //do something
}
else
{
    //do something else
}

Меня всегда удивляло, насколько это расточительно, особенно в выражениях if / else. И я знаю, что в более поздних версиях C # существуют альтернативы, такие как:

if(myBoolean == true)
    //do something on one line of code

Но вряд ли кто-то использовал их. Каждый делал что-то вроде фигурных скобок.

Затем я вернулся к созданию JavaScript после долгого отсутствия. На моей памяти разработчики JavaScript делали то же самое, что и curly-brace-newline, но со всеми новыми модными библиотеками и прочим, большинство разработчиков ставят открывающую скобку после объявления:

function MyJavaScriptFunction() {
    //do something
}

В этом вы можете увидеть смысл, потому что, поскольку использование JavaScript и указателей на функции стало популярным в JavaScript, оно экономит много места и делает вещи более читабельными. Поэтому я удивился, почему в C # это не считается готовым делом. Фактически, если вы попробуете описанную выше конструкцию в Visual Studio 2013, она фактически отформатирует ее для вас, поместив открывающую скобку в новую строку!

Теперь я только что увидел этот вопрос на Code Review SE: https://codereview.stackexchange.com/questions/48035/questions-responses-let-me-tell-you-about-you, в котором я узнал, что в Java Язык, с которым я не слишком хорошо знаком, считается неукоснительным открывать свои фигурные скобки сразу после объявления в современном стиле JavaScript.

Я всегда понимал, что C # был изначально смоделирован после Java и придерживался многих из тех же самых стандартов базового кодирования. Но в данном случае, похоже, нет. Поэтому я предполагаю, что должна быть веская причина: в чем причина? Почему разработчики C # (и Visual Studio) применяют открывающие фигурные скобки на новой строке?

Скобка в конце строки - это древний стандарт K & R C из книги Брайана Кернигана и Денниса Ричи « Язык программирования C» , который они опубликовали в 1978 году после совместного изобретения операционной системы UNIX и языка программирования C (я думаю, что C был в основном разработано Ричи), в AT & T.

Раньше были пламенные войны за «единый истинный стиль скобок».

Ричи изобрел язык Си, а Керниган написал первый урок, когда на компьютерных дисплеях отображалось всего несколько строк текста. Фактически, разработка UNICS (позже UNIX) началась на DEC PDP-7, который использовал пишущую машинку, принтер и бумажную ленту для пользовательского интерфейса. UNIX и C были закончены на PDP-11 с 24-строчными текстовыми терминалами. Так что вертикальное пространство действительно было на высоте. У всех нас сегодня немного лучшие дисплеи и принтеры с более высоким разрешением, верно? Я имею в виду, я не знаю о вас, но у меня есть три (3) 24 "1080p дисплеи прямо сейчас передо мной. :-)

Кроме того, большая часть этой маленькой книги «Язык программирования Си» - это примеры кода, в которых размещение скобок на концах строк, а не на собственных строках, якобы сэкономило значительную сумму денег на печати.

Что действительно важно, так это согласованность во всем проекте или, по крайней мере, в данном файле исходного кода.

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

if( true )
    {
    // do some stuff
    }

Кстати, C # всегда поддерживал оценку одной команды после выражения ветвления. На самом деле, это единственное, что он делает, даже сейчас. Помещение кода в фигурные скобки после выражения ветвления просто превращает эту команду в команду goto (компилятор создает область видимости, используя инструкции jmp). C ++, Java, C # и JavaScript все более или менее основаны на C, по большей части с теми же базовыми правилами синтаксического анализа. Так что в этом смысле C # не «основан на Java».

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

РЕДАКТИРОВАТЬ : просто посмотрите на ошибку Apple, чтобы goto failувидеть прекрасный пример этой проблемы, которая имела очень серьезные последствия в реальном мире.

if( true )
    doSomething();

становится ...

if( true )
    doSomething();
    doSomethingElse();

В этом случае doSomethingElse()выполняется каждый раз, независимо от результата теста, но, поскольку он имеет отступ на том же уровне, что и doSomething()оператор, его легко пропустить. Это на самом деле не спорно; изучает это. Это большой источник ошибок, добавленных в исходный код во время обслуживания.

Тем не менее, я признаю, что синтаксис закрытия JavaScript выглядит немного глупо с фигурными скобками на своих линиях ... эстетически. :-)

Разработчики на C # делают это потому, что это настройка по умолчанию для автоформатера Visual Studio. Хотя этот параметр можно изменить, большинство людей этого не делают, и поэтому все разработчики в команде должны согласиться с большинством.

Что касается того, почему это по умолчанию в Visual Studio, я не знаю.

Как я и предполагал в этом ответе, здесь - https://softwareengineering.stackexchange.com/a/159081/29029 - я полагаю, что решение использовать готовность Аллмана могло быть признаком наследия Паскаля, учитывая, что Хейлсберг создал Delphi до того, как он разработал C # , То же, что и в случае Паскаля для имен методов.

Лично я верю в следование пословице "в Риме делай, как римляне". Я использую Allman's в C #, но K & R в Java. Я так привык к этому, что переключение конвенции в любом случае раздражает меня.

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

Соглашение, которое вы связываете с Java, - это стиль K & R, или «Один истинный стиль фигурной скобки», и изначально происходит от C. Этот стиль отступа страницы из почтенного Jargon File показывает, сколько лет различию.

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