实现“LazyProperty”类 - 这是一个好主意吗？

我经常发现自己编写的属性是惰性评估的。就像是：

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 属性？

欢迎提出意见和建议:-)

只是过于迂腐：

您建议的避免重复代码的解决方案：

private LazyProperty<HeavyObject> first = 
  new LazyProperty<HeavyObject>(() => new HeavyObject { MyProperty = Value });
public HeavyObject First { 
  get { 
    return first; 
  } 
}

实际上比您不想重复的代码更多的字符：

private HeavyObject first;
public HeavyObject First { 
  get {
    if (first == null) first = new HeavyObject { MyProperty = Value };
    return first;
  }
}

除此之外，我认为隐式转换使代码非常难以理解。我不会猜到一个简单地首先返回的方法实际上最终会创建一个 HeavyObject。我至少会放弃隐式转换并从属性返回first.Value。