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

我经常发现自己写的是惰性评估的属性(property)。就像是:

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。

关于c# - 实现 "LazyProperty"类-这是一个好主意吗？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/440290/