Какое соглашение об именах использовать для параметров функции C #

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

пример,

void MyFunc(BaseClass myPara)
{
  DerivedClass _mypara = (BaseClass)myPara;
}

или наоборот

void MyFunc(BaseClass _myPara)
{
  DerivedClass mypara = (BaseClass)_myPara;
}

или любой другой условно

Добавление префикса к параметрам или локальным переменным не очень идиоматично в C #, его не очень легко читать и не часто использовать (хотя это допустимо, поэтому вы можете сделать это, если хотите).

Лучшее имя для параметра и переменной - это описательное имя. Вам нужно подумать, почему вы меняете тип, в чем причина каста. Тогда вы сможете придумать 2 разных имени. Например, если вы передали «person» и преобразовали его в «customer», то вы можете использовать person и / или customer в именах переменных, возможно.

Если вы действительно не можете думать о двух разных именах, тогда я бы использовал «как» в названии ( несколько дней назад на этом сайте был вопрос об этом ). Например, вы бы использовали «myParaAsDerived» для локальной переменной.

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

Во-первых, используя

void MyFunc(BaseClass _myPara)
{
} 

Явно неправильно! Поскольку многие стандарты кодирования в c # используют префикс «_» для всех имен полей ! Ваш код должен быть легок для понимания другим программистом, поэтому код не должен быть написан так, чтобы вводить в заблуждение многих программистов на C #.

Учитывая все преимущества небольших методов, я лично не вижу необходимости в соглашении об именах для отделения локальных переменных от параметров. Если у ваших методов так много параметров и локальных переменных, что вы не можете сказать, что происходит без соглашения об именах, у вас большие проблемы. (Это хорошо описано в Чистой книге кодов, книге на Java, но я все же нашел ее очень полезной как программист на C #)

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

Хорошее общее правило с именами переменных выглядит так:

• Если у вас есть только один тип имени объекта, то по его функции:

  var builder = new PizzaBuilder();

• Если у вас есть несколько названий их по функциям и специализации:

  var pizzaBuilder = new PizzaBuilder();
  var milkShakeBuilder = new MilkShakeBuilder();

Соглашения об именах C # будут иметь вас:

• Использование PascalCasing для методов, открытых свойств и имен классов
• Использование IPascalCasing (обратите внимание на I в начале) для имен интерфейсов
• Использование camelCasing для параметров метода и локальных переменных
• Использование _underscoredCamelCasing для частных полей всего класса

И, пожалуйста, держитесь подальше от венгерской нотации. Это бессмысленно и не соответствует соглашениям C #.

Подчеркивание в именовании переменных может быть излишним, так как у нас есть ключевое слово «this» для конкретной ссылки на переменные уровня класса. Если вы хотите больше узнать о соглашениях по именованию переменных от экспертов, я бы посоветовал вам взглянуть на печально известную статью Тима Оттингера «Правила Оттингера для именования переменных и классов», статью которой поддержал наставник по чистому кодированию Роберт С. Мартин. ,

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

public void Function(string p_Parameter1, string p_Parameter2)

... будет более читабельным, как ...

public void Function(string parameter1, string parameter2)

... где parameter1 и 2 - описательные имена для соответствующих переменных.

Вот ссылка, безусловно, стоит посмотреть: Ссылка

Я верю в суффикс параметра: строка s_, int i_ и т. Д.

Я также считаю, что имена парм должны быть как можно более краткими и общими.

Теперь по причинам:

• В функции вы не хотите изменять параметр каким-либо образом, если вам нужна измененная версия, создайте новую переменную, чтобы вставить ее. Присвоение имен пармам с суффиксом позволит вам не назначать их, если вы платите внимание.
• Исключения из этого правила происходят, когда параметр является ref или out. Хотя я все еще использую суффикс на тех.
• Почему короткие общие имена? Вы должны документировать свою функцию, чтобы знать, что на самом деле представляет собой s_. Таким образом, при использовании коротких обобщений удобно создавать группы похожих функций или вырезать тело функции для переноса в другую функцию в качестве начальной точки для модификации.
• Настоящее преимущество общих имен в том, что вам не нужно вспоминать то, что вы называли этим параметром в большинстве случаев. Вы знаете, что получаете строку, так что это s_ и т. Д., И вам не нужно задаться вопросом, является ли это «именем файла», или это был «путь к файлу», или это был «полный путь», единственная строка, так что это «s_».

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