Защищенные члены / полями действительно так плохо?

StackOverflow https://stackoverflow.com/questions/3182653

Вопрос

Теперь, если вы прочитаете конвенции именования в MSDN для C #, вы заметите, что он утверждает, что свойства всегда предпочтительны над публичными и защищенными полями. Некоторые люди даже сказали, что вы никогда не должны использовать публичные или защищенные поля. Теперь я согласен, что я еще предстоит найти причину, в которой мне нужно иметь публичное поле, но охраняемые поля действительно так плохо?

Я вижу его, если вам нужно убедиться, что определенные проверки проверки выполняются при получении / установлении значения, однако много времени, когда это кажется просто дополнительным накладным расходом. Я имею в виду, давайте скажем, у меня есть класс игры с полями для базового значения, PrefixName и Sugsixname. Почему я должен взять накладные расходы обоих создание свойств (C#) или методы доступа и удары производительности я бы возникнут (если я сделаю это для каждого поля в приложении, я уверен, что он добавляет меньше, особенно на определенных языках, таких как PHP Или определенные приложения с производительностью являются критическими как игры)?

Это было полезно?

Решение

Защищенные члены / полями действительно так плохо?

Нет, они способны хуже.

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

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

То Лучший способ поделиться информацией с получением классов только для чтения свойства:

protected object MyProperty { get; }

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

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

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

Другие советы

ОК, Время вниз

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

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

Остальные аргументы беспокоят меня таким образом:

  • Они звучат как «аргумент от prestige». Если MSDN говорит это, или какой-то известный разработчик или автор, которым все лайки говорят, это должен быть так.

  • Они основаны на идее того, что структуры данных имеют много непоследовательных государств, и должны быть защищены от странствия или помещения в те государства. Так как (мне кажется) структуры данных - это чрезмерно подчеркиваемые в текущем преподавании, то обычно они делать нужны эти защиты. Гораздо более предпочтительнее Минимизировать структуру данных Так что он имеет тенденцию быть нормализованным и не иметь противоречивых государств. Затем, если член класса изменен, он просто изменен, а не поврежден. В конце концов, как-то много хорошего программного обеспечения было / написано в C, и это не сильно страдало от нехватки ограждений.

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

Что касается полей vs. Свойства, я могу подумать о двух причинах для предпочтения свойств в общественном интерфейсе (защищена также общественности в том смысле, что кто-то другой, чем просто ваш класс).

  • Раскрытие свойств дает вам способ скрыть реализацию. Он также позволяет вам изменить реализацию без изменения кода, который его использует (например, если вы решите изменить данные, данные хранятся в классе)

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

Что касается накладных расходов:

  • Если Getter / Setter является обычным количеством линейной частью кода, который просто читает / устанавливает значение поля, то JIT должен быть встроен на вызов, поэтому нет прокола производительности.

  • Синтаксический накладной расходы в значительной степени уменьшается при использовании автоматически реализованных свойств (C # 3.0 и новее), поэтому я не думаю, что это проблема:

    protected int SomeProperty { get; set; }

    На самом деле, это позволяет сделать, например, set защищенный и get Очень легко, поэтому это может быть еще более элегантно, чем использование полей.

Общественные и / или защищенные поля плохие, потому что они могут быть манипулируются из-за пределов декларирующего класса без проверки; Таким образом, их можно сказать, что сломает принцип инкапсуляции объектно-ориентированного программирования.

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

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

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

Но когда я на работе, это другая история.

Это на самом деле зависит от того, если ваш класс является классом данных или класс поведения.

если ты Держите свое поведение и данные отдельно, нормально предоставить данные ваших классов данных, пока они не имеют поведения.

Если класс является классом поведения, то он не должен подвергать никаких данных.

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top