то пишу свойство, которое оценивается лениво. Что-то вроде:

if (backingField == null) 
  backingField = SomeOperation();
return backingField;

Это не так много кода, но он многократно повторяется, если у вас много свойств.

Я думаю об определении класса с именем LazyProperty:

public class LazyProperty<T>
    {
    private readonly Func<T> getter;

    public LazyProperty(Func<T> getter)
    {
        this.getter = getter;
    }

    private bool loaded = false;
    private T propertyValue;

    public T Value
    {
        get
        {
            if (!loaded)
            {
                propertyValue = getter();
                loaded = true;
            }
            return propertyValue;
        }
    }

    public static implicit operator T(LazyProperty<T> rhs)
    {
        return rhs.Value;
    }
}

Это позволило бы мне инициализировать поле следующим образом:

first = new LazyProperty<HeavyObject>(() => new HeavyObject { MyProperty = Value });

И тогда тело объекта может быть уменьшено до:

public HeavyObject First { get { return first; } }

Это будет использоваться большинством компаний, поскольку оно войдет в общую библиотеку классов, используемую большинством наших продуктов.

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

Меньше кодаБолее красивый код

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

Как вы думаете ? Это хорошая идея или я должен отказаться от нее? Кроме того, является ли неявный оператор хорошей идеей, или вы предпочитаете явно использовать свойство Value, если вам следует использовать этот класс?

Мнения и предложения приветствуются :-)