Инкапсуляция, очевидно, полезна и необходима при доступе к членам извне класса, но при обращении к переменным класса внутри, лучше ли звонить своим частным членам или использовать их получатели? Если ваш getter просто возвращает переменную, есть ли разница в производительности?Каковы преимущества использования внутренних свойств?
Не должно быть существенной разницы в производительности, и причина, по которой вы придерживаетесь этих свойств, заключается в том, что это целая инкапсуляция. Он обеспечивает полный доступ к этим частным членам, последовательно и контролируемым. Поэтому, если вы хотите изменить свойство getter/setter, вам не нужно думать «нужно ли дублировать те же функции в других местах, где я решил напрямую обратиться к частному пользователю?»
Выгода будет в тех случаях, когда в Get или Set была сделана проверка. Это было бы в одном месте и всегда называлось.
Насколько я знаю (из других вопросов, заданных по переполнению стека), когда Getter просто возвращает значение, генерируемый код такой же, как для прямого доступа к переменной.
Доступ к полю напрямую или с использованием геттера обычно не имеет большого значения, если только ваш геттер не выполняет какую-либо ленивую инициализацию или другую обработку. Так что это зависит от того, что делает геттер, но мое эмпирическое правило - всегда использовать геттер, за исключением конкретных случаев.
Чтобы присвоить значение полю, не забудьте, что сеттеры часто включают в себя код проверки или поднять событие. В этом случае вы всегда должны использовать установщик.
+1: Это хорошее эмпирическое правило. Существует общая тенденция использования частного участника. «Я ничего не делаю в геттере и/или сеттере ... было бы расточительно вызвать метод ... Я просто сделаю задание ... cool «. (виновен. Я признаю это). Затем вы, или, что еще хуже, добавили некоторую валидацию в сеттера и ... ударили ... свою цель у того, кто застрелил встречу с кроликом. Как сказал Томас ... всегда есть место для исключения особых случаев ... по привычке использовать сеттера. – Rusty
В любом случае, простые геттеры или сеттеры обычно встраиваются компилятором JIT, поэтому даже не оптимизировать доступ к полю напрямую ... –
Разница в производительности пренебрежимо, примерно в 98% случаев.
Вы всегда должны использовать свойства, даже если ваш геттер или сеттер просто получают или задают ваш частный член. Это позволит вам вносить изменения по мере развития вашего приложения. Таким образом, вы сможете вносить некоторые ограничения или некоторые другие инкапсуляции в свои свойства, не нарушая ваш код. В противном случае, как только вы решите написать свойства из-за причины X, вы обнаружите, что обязаны реорганизовать весь свой код, чтобы получить или установить свойство вместо своего частного члена.
Мне нравится использовать внутренние свойства для ленивой инициализации, где в свойстве вы убедитесь, что объект инициализирован. Это гарантирует, что я не использую переменные уровня класса, которые еще не были инициализированы.
TestClass1 _class1
internal TestClass1
{
get
{
if (_class == null)
_class = new TestClass1()
return _class1
}
}
попытайтесь спросить Ваш сам этот вопрос: если вы считаете, что ваше собственное заявление (которое я не вижу никаких причин, почему вы не должны) «Encapsulation, очевидно, полезно и важно, когда доступ пользователей из вне класса», а затем попытаться прийти с твердым аргументом в пользу того, почему все должно быть по-другому, если вы удалили последние четыре слова. Если вы не знаете, что можете использовать те же аргументы :) –
@ChrisF: эта тема в значительной степени не связана с этим вопросом – fearofawhackplanet
Ссылка на то, что оказалось ненужным вопросом, удаленным. – ChrisF