При реализации класса “LazyProperty” - действительно ли это - хорошая идея?

Не делайте этого вообще.

Обычно использование этого вида ленивых инициализированных свойств является допустимым проектным решением в одном случае: когда SomeOperation(); дорогая операция (с точки зрения ввода-вывода, как то, когда он требует хита DB, или в вычислительном отношении), И когда Вы будете уверены, что НЕ должны будете часто получать доступ к нему.

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

Если Вы чувствуете желание создать такую абстракцию, это - запах.

Конечно, Вы, по крайней мере, хотели бы LazyPropery<T> чтобы быть типом значения, иначе Вы добавили память и давление GC для каждого "лениво загруженного" свойства в Вашей системе.

Кроме того, что относительно нескольких - распараллелил сценарии? Рассмотрите два потока, запрашивающие свойство одновременно. Без блокировки Вы могли потенциально создать два экземпляра базового свойства. Чтобы постараться не привязывать общий падеж, Вы хотели бы сделать перепроверяемую блокировку.

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

Что я делаю в этом случае, я создаю фрагмент кода Visual Studio. Я думаю, что это - то, что действительно необходимо сделать.

Например, когда я создаю средства управления ASP.NET, я часто, времена имеют данные, которые хранятся в ViewState много, таким образом, я создал фрагмент кода как это:

public Type Value
{
    get
    {
        if(ViewState["key"] == null)
            ViewState["key"] = someDefaultValue;
        return (Type)ViewState["key"];
    }
    set{ ViewState["key"] = value; }
}

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

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

Относительно неявного свойства мне нравится свойство "Value" лучше. Это немного больше вводит, но намного более ясный мне.

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

Если Вы думаете, что затем ничего не могли сделать из страха перед кем-то не понимающим, что Вы сделали

Вы могли записать учебное руководство или что-то в центральном репозитории, у нас есть здесь Wiki для подобных примечаний

В целом, я думаю, что это - хорошая идея реализации (не желание запустить дебаты, является ли lazyloading хорошей идеей или не),

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

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

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

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

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

Я думаю, что это - интересная идея. Сначала я рекомендовал бы скрыть Ленивое Свойство от кода вызова, Вы не хотите просачиваться в свою модель предметной области, что это лениво. Который Ваше выполнение с неявным оператором так сохраняют этим.

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

Вы можете использовать итераторы C #. В следующем сообщении объясняется пример использования и преимущества его использования.

http://hemanshubhojak.com/Home/Post? postId = 3