c# - 实现一个 "LazyProperty"类——这是个好主意吗？

Question

我经常发现自己编写的属性是惰性求值的。像这样的东西:

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; } }

这将被公司的大多数人使用，因为它将进入我们大多数产品共享的公共(public)类库。

我无法决定这是否是个好主意。我认为解决方案有一些优点，例如:

• 更少的代码
• 更漂亮的代码

不利的一面是，查看代码并确定到底发生了什么会更加困难 - 特别是如果开发人员不熟悉 LazyProperty 类。

你怎么看？这是一个好主意还是我应该放弃它？ 另外，隐式运算符是个好主意，还是如果您应该使用此类，您更愿意显式使用 Value 属性？

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

Answer 1

只是过于迂腐:

您提出的避免重复代码的解决方案:

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。