Как вы называете ваши личные переменные в C #? [закрыто]

Какова лучшая практика, наиболее распространенные соглашения об именах для частных переменных в C #?

1. private int myInteger;
2. private int MyInteger;
3. private int mMyInteger;
4. private int _myInteger;
5. private int _MyInteger;
6. Таинственный другой вариант

Что вы используете и почему? (Моя компания довольно плохо знакома с C #, и я хотел бы выбрать наиболее «приемлемый для отрасли» метод, чтобы попытаться войти в наш стандарт кодирования.)

Руководства по проектированию классов MSDN http://msdn.microsoft.com/en-us/library/ta31s3bc.aspx рекомендует вариант 1 - myInteger.

Я всегда использовал этот стиль. У меня есть личная неприязнь к персонажу _.

Я использую вариант № 4 выше:

private int _myInteger;

Мне нравится иметь некоторую индикацию области видимости в моих именах переменных, и для этого достаточно подчеркивания. Это также довольно легко читать.

Я использую следующую схему именования:

• 1-е (myInteger) для локальных переменных области
• 2-й (MyInteger) для публичных объектов
• 4-е (_myInteger) для приватных переменных

Я думаю, что вариант 4 действительно самый читаемый вариант. Это помогает вам сделать это:

public Person(string name, int age) 
{
    this.name = name;
    this.age = age;
}

Это также делает всех частных членов более заметными. В следующем примере, откуда черт возьми age? Без thisклассификатора это сложнее сказать.

private void Method()
{
    var x = 2;
    var y = age + x;
}

Это легче понять:

private void Method()
{
    var x = 2;
    var y = _age + x;
}

Прежде всего, PascalCasing обычно зарезервирован для открытых свойств, констант, методов и т. Д. Класса. Так что я бы пропустил 2 и 5.

Во-вторых, венгерская нотация не приветствуется в мире .NET, поэтому (ну, я думаю) 3 - правильная. Предполагая, что это то, что происходит с 3.

Это выходит с CamelCasing и _camelCasing. Я обычно использую _camelCasing для переменных класса, и обычный старый camelCasing для переменных, ограниченных методом или более узким. Оболочка верблюда является общепринятым стандартом, используемым для аргументов метода, имен защищенных / закрытых переменных и переменных внутри метода или более узкой области.

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

private int integer

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

Я считаю, что лучший способ сделать это (в любом случае в C # /. Net) - это сочетание 2 и 6:

private int MyInteger { get; set; }

Здесь теоретически нет никакой переменной, но она выглядит и действует как частная переменная экземпляра. Если нам нужно добавить некоторую бизнес-логику к этому значению (это полностью внутреннее значение, так что мы можем все, что мы хотим для него сделать в конце концов), то это уже «для нас». Горячий дымящийся кубок победы!

Я выбрал вариант № 4, потому что именно так выглядит SSCLI, но, честно говоря, меня не особо заботит наименование приватной переменной. Публика - это другая история.

Кстати, вы забыли m_MyInteger

Я бы не назвал это "моим" чем-либо!

Но я бы сказал

class C
{
     int VariableName { get; set; }
}

довольно часто это лучше, чем наличие явных переменных. Если бы у меня была явная приватная переменная, я бы назвал ееint _variableName;

В C ++ я склонен использовать _, поскольку я часто переключаю редакторы, что не позволяет мне увидеть, является ли это приватным.

Для C # я склонен не использовать _, поскольку Visual Studio позволяет мне увидеть, является ли он закрытым.

Я склонен использовать Camel Case, чтобы сделать это.

Я использую 4 ( private int _myInteger;), потому что:

private int myInteger;

Вот как я называю свои локальные переменные.

private int MyInteger;

Вот как я называю константы.

private int mMyInteger;

Это не стиль C #.

private int _MyInteger;

Это выглядит странно

с подчеркиванием.

Билл Вагнер объясняет, почему в Effective C # . Но я бы никогда не назвал целое число моим Integer , лучше что-то вроде _age или _length. Включение TypeName в имя экземпляра - ужасная практика. Имена должны быть самоочевидными, и, поскольку C # является типобезопасным типом, его можно найти в любое время.

Вам нужно привести более конкретный пример, но:

private int count, private int badFileCount,private static readonly int ReconnectAttemptsLimit

Кстати, вы получаете все это БЕСПЛАТНО, когда вы устанавливаете и начинаете использовать новейшие и лучшие MSFT Stylecop.

Я иду по варианту 5: private int _MyFoo

Я не вижу никакого реального конкурентного преимущества перед _myFoo.

Используйте camelCasing для частных переменных, таких как myInteger

Рассмотрим предыдущее, _если переменная является резервной копией свойства, чтобы уменьшить путаницу.
Переменная _myPropertyдля свойстваMyProperty

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

Стандарт кодирования IDesign C # Ювала Лоуи довольно популярен. Этот стандарт рекомендует ставить префикс закрытых членских переменных с помощью «m_» (опция 6). Это то, что мы делаем в нашей команде.

private int m_myInteger;

Вариант 4 ( _myInteger) является приемлемым вариантом данного стандарта.

Мне не понравилась рекомендация MSDN ( myInteger), потому что она затрудняет выделение частного члена из локальной переменной. Их рекомендация, конечно, решает эту проблему путем квалификации частных членов this, что мне кажется излишним.