C # - Почему префиксы на полях не рекомендуется?

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

Для меня, если я читаю чужой код и вижу это:

count = 3;

Я предполагаю, что countэто локальная переменная для этой функции, и я делаю что-то, что будет использоваться в другом месте функции; если я увижу это:

m_count = 3;

Я сразу понимаю, что я обновляю состояние объекта.

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

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

Я счастлив изменить стиль Microsoft, но я бы хотел знать, почему все так, как есть.

Почему сейчас считается плохим иметь возможность определять, является ли переменная локальной функцией или членом?

PS Это очень похоже на то, что в настоящее время считается наилучшей практикой в ​​отношении ключевого слова «это» перед полем и методами в c #? но я спрашиваю m_неthis.

PPS Также см. Почему Microsoft сделала так, чтобы параметры, локальные переменные и частные поля имели одно и то же соглашение об именах?

Когда они работали над API для Windows, Microsoft рекомендовала использовать венгерскую нотацию, используя «m_», а также «i», «sz» и т. Д. В то время это было полезно, поскольку среда IDE не была устойчивой. достаточно, чтобы показать эту информацию для вас.

C #, с другой стороны, имеет очень надежную IDE с самого начала.

Таким образом, они сделали рекомендацию в Microsoft Naming Guidelines for C # для открытых статических или защищенных полей:

✓ DO use PascalCasing in field names.
✓ DO name fields using a noun, noun phrase, or adjective.
X DO NOT use a prefix for field names.

Теперь, когда вы можете навести на него курсор мыши или нажать CTRL + K + W и получить всю информацию об участнике, Microsoft пришла к выводу, что префиксы являются неправильной формой; это ручное решение уже решенной проблемы.

Частные поля специально исключены из руководящих принципов, но Microsoft, похоже, пришла к выводу, что это относится даже к внутренним частным полям, которые можно увидеть, если вы укажете Resharper на .NET 4.5 или .NET Core.

Используйте свои инструменты, не делайте это вручную.

В C # нет глобальных переменных, поэтому остаются только локальные переменные и поля классов.

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

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

Теперь, когда мы установили, что цель украшений «это член» больше не выполняется, поскольку область действия функции должна быть слишком маленькой, а глобальная область не существует, у этих маркеров есть один недостаток: они препятствуют перемещение аргументов / локальных переменных в члены или наоборот.

Почему разработчики избегают добавления пространств имен с помощью директивы using namespace?

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

Нет. Мы ленивые машинистки, но это не то, почему.

Мы предпочитаем стили кодирования, которые позволяют нам игнорировать детали и сосредоточиться на абстракциях. Принуждение имен сообщать детали структуры отвлекает. Когда я работаю над сложным алгоритмом, я не хочу, чтобы имена требовали напоминать мне каждую мелочь о том, с чем я работаю. Мне просто нужно имя, чтобы не запутать меня Timerи DateTime. Я буду беспокоиться о том, совместимы ли они где-нибудь еще.

По той же причине вы не хотите, чтобы в вашей команде было два парня по имени Джон. Тот факт, что у них есть фамилии, не является причиной для присвоения им префиксов или суффиксов. Я просто буду звать тебя Скит. Все остальное - просто боль.

Давайте немного расширим.

Существует 3 общих стиля префиксов, каждый из которых иногда встречается в коде c #:

• m_
• _
• это.

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

Преимущество использования m_over _заключается в том, что префикс может быть одинаковым во всей вашей кодовой базе, если вы используете c #, а также языки, где использование _в качестве префикса недопустимо . * Преимущество m_over в this.том, что он короче и вы случайно не будете забудь про префикс.

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

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

* Как только вы начнете получать доступ к классам C #, которые используют _из C ++ / CLI (которые действительно не должны использовать _), вы заметите, что согласование общего префикса является более сложным, чем должно быть. Решение не иметь префикса избавляет от этого шума. Объедините это с ответом Дедупликатора, который я перефразирую как «преимущество префикса практически ничтожно», и это дает нам: «При использовании префиксов есть крошечная проблема и крошечный потенциал роста, поэтому это правильный выбор - просто не используй их".

Есть более старый вопрос о стековом потоке, связанный с этим.

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

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

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

Сказав, что переменные префиксы вообще не рекомендуется по ряду причин

• Они могут ошибаться и, следовательно, вводить в заблуждение
• Если вы используете префикс по типу переменной, неясно, как вы обрабатываете созданные вами классы.
• Есть ряд соглашений, и они не всегда согласны. Что вы считаете полезным, другой разработчик может найти бесполезным
• В случае переменных-членов вы можете использовать это «это». ключевое слово, чтобы указать область, и компилятор будет применять его.

Для меня, если я читаю чужой код и вижу это:

count = 3;

Я предполагаю, что 'count' является локальной переменной для этой функции, и я делаю то, что будет использоваться в другом месте в функции

И вы будете абсолютно правы, если вы читаете исходный код, который соблюдает правила стиля C #. В таком коде:

this.count = 3;

присваивает значение полю.

count = 3;

присваивает значение локальной переменной

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

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

public class Hello
{
    private string greetings;

    public Hello(string greetings)
    {
        greetings = greetings; // Wait, what is that?!
    }
}

Разве в C # нет ключевого слова this? Не могли бы вы сослаться на участников, использующих это, таких как this.count?

Да, но (1) это больше печатать, и (2) это легко забыть. Если поле называется m_count, мне не нужно помнить, чтобы ввести this.m_count

Здесь, однако, вы не правы.

Это больше печатать, когда вы пишете свой код в блокноте. С IDE с авто-завершения или, лучше, IntelliSense, сравнение между this.countи m_countне столь очевидна. Обратите внимание на Shiftзнак +, -необходимый для ввода подчеркивания.

Что касается «легко забыть», опять же, это актуально только для пользователей Блокнота. Не только StyleCop и Resharper не позволят вам забыть, что this.нужно делать, когда это необходимо, но после нескольких часов программирования, this.когда это необходимо, это становится привычкой.

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

можешь объяснить дальше? Ваша единственная причина, по которой я видел, почему не использовать префикс, и я не понимаю его ... (под этим я подразумеваю, что другие люди говорят, что это причины, по которым я не должен его использовать, что не то же самое, что почему я не должен) - Бетти Кроккер

Я хочу расширить ответы @CandiedOrange и @Ewan.

Префиксы усложняют рефакторинг

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

Допустим, вы создали налоговый калькулятор. В соответствии с принципом видимости аренды для переменных вы начинаете с метода, который принимает как налоговую ставку, так и базовое значение в качестве параметров:
^{(пример может выглядеть как Java-иш ...)}

class TaxCalculator{
   double Calculate(double p_TaxRateInpercent, double p_BaseValue){
     return (100+p_TaxRateInpercent)/100 * p_BaseValue;
   }
} 

Затем вы должны выполнить обратную операцию, и в соответствии с TDD вы делаете это с наименьшими усилиями:

class TaxCalculator{
   double Calculate(double p_TaxRateInpercent, double p_BaseValue){
     return (100+p_TaxRateInpercent)/100 * p_BaseValue;
   }
   double CalculateBase(double p_TaxRateInpercent, double p_TaxedValue){
     return p_TaxedValue/((100+p_TaxRateInpercent)/100);
   }
} 

Далее TDD хочет, чтобы вы реорганизовали код, чтобы он стал чище, что должно уменьшить список параметров обоих методов.
^{(Да, вы бы сначала извлекли удвоенные вычисления, но позвольте мне понять мою точку зрения ...)}
Очевидное решение - изменить налоговую ставку на переменную-член, передав ее в качестве параметра конструктора.

class TaxCalculator{
   double m_TaxRateInpercent;
   TaxCalculator(double p_TaxRateInpercent){
     m_TaxRateInpercent = p_TaxRateInpercent;
   }
   double Calculate(double p_BaseValue){
     return (100+m_TaxRateInpercent)/100 * p_BaseValue;
   }
   double CalculateBase(double p_TaxedValue){
     return p_TaxedValue/((100+m_TaxRateInpercent)/100);
   }
} 

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

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

Без префикса изменились бы только сигнатуры метода. Переименование не понадобилось бы вообще.

Префиксы загромождают историю SCM при изменении

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

Я использую префикс _ для всех переменных-членов. Я ненавижу префикс «this», потому что, хотя некоторые утверждают, что это правильный способ работы - он добавляет много шума / беспорядка в вашу кодовую базу. Отдельное подчеркивание также является обычной практикой в ​​примерах Microsoft.

Так что в вашем примере я бы имел:

int _count = 10;