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

Учитывая, что эти два примера эквивалентны, как вы думаете, предпочтительнее?

Без явного модификатора

public class MyClass
{

    string name = "james";

    public string Name {
        get { return name; }
        set { name = value; }
    }

    void SomeMethod() { ... }

}

С явным модификатором

public class MyClass
{

    private string name = "james";

    public string Name {
        get { return name; }
        set { name = value; }
    }

    private void SomeMethod() { ... }

}

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

Ответы

Ответ 1

Я думаю, что экспликация, заявляющая о себе, помогает в удобочитаемости. Это не позволит программисту интерпретировать свою видимость по-разному.

Ответ 2

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

Меня беспокоит то, что публичные и частные так похожи, длина 6-7 символов, синяя, начиная с "p", поэтому гораздо сложнее указать публичный метод между 10 явными частными, чем между 10, у которых нет атрибута доступа.

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

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

Кроме того, мне обычно нравится, когда код прост и понятен математическим способом, когда код явный, чтобы сохранить будущее незнание кодера. Это путь VB, а не С#...

Ответ 3

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

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

Прояснить... сделать его явным; -p

Ответ 4

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

В С# все по умолчанию имеет наименьшую возможную видимость. Член класса (поле, метод, свойство) по умолчанию является закрытым. Класс по умолчанию является внутренним. Вложенный класс по умолчанию является закрытым.

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

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

(К сожалению, это правило справедливо только для С#. В VB.NET и F # значения по умолчанию совершенно разные и в большинстве случаев определенно не "наименьшая видимость возможна".)

Ответ 5

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

Мне нравится явное объявление моего намерения при кодировании. И то, и другое, потому что объявления для меня видны, когда я возвращаюсь и смотрю на него, а потому, что на самом деле думая и набрав слово "private", когда я пишу метод, заставляет меня думать немного больше о том, что я имею в виду сделать.

Ответ 6

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

Ответ 7

Мне нравится быть супер-явным обычно. Я поеду для указания "private" всегда. Однако есть и другая причина: программисты, выходящие из языков программирования, где видимость по умолчанию НЕ закрыта, но общедоступна, например PHP.

Ответ 8

Я всегда предпочитаю быть явным, даже если он избыточен. Это обеспечивает встроенные комментарии к коду и может быть полезным для следующего парня, особенно если он нооб.: -)

Ответ 9

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

Кроме того, когда вы говорите о различных типах структур, у них могут быть разные возможности по умолчанию. Без явных модификаторов ownus читает читателю, какая структура имеет значение по умолчанию. Например. в С#, по умолчанию для структурных полей public, по умолчанию для полей класса private, а определения классов по умолчанию - internal.

Ответ 10

Я все время говорю явное. Если ничто иное не демонстрирует ваше намерение более четко. Если я хочу, чтобы что-то было частным, я скажу так. Явно набрав модификатор, я думаю об этом, а не просто оставляя вещи частными, потому что он быстрее. Что длинный список участников лучше подходит:)

Ответ 11

Я всегда указываю видимость явно. Я предпочитаю не давать компилятору догадываться о моих намерениях.

Ответ 12

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

Ответ 13

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

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

Ответ 14

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

Если вам нужно определить соглашение, я буду настаивать на явном способе.

Мои причины?;

  • Мне нравится сохранять одну и ту же структуру (я имею в виду модификатор a.-access, b.-return-type/type, c.-name).
  • Я не хочу (и я не ожидаю других) помнить все модификаторы по умолчанию (которые приведены здесь).
  • Не все языки имеют одинаковые правила.
  • И почему-то я думаю, что это как-то заставляет разработчика задуматься и быть более сознательным в области действия переменной/метода и изложения этих. Если у вас есть опыт, это, вероятно, не применимо, но если вы новичок или работаете с людьми с меньшим опытом, я считаю, что это полезно.