C# 懒惰的属性要求；这"；

这里是一个例子，我有一个属性，编码尽可能简单

private IEnumerable<int> _blocks;
private bool _blocksEvaluated;
public IEnumerable<int> Blocks
{
    get
    {
        if (!_blocksEvaluated)
        {
            _blocksEvaluated = true;
            _blocks = this.CalculateBlocks(0).FirstOrDefault();
        }
        return _blocks;
    }
}

私有IEnumerable\u块；
私人楼宇估价；
公共可数大厦
{
得到
{
如果（！\u blocksEvaluated）
{
_blocksEvaluated=true；
_blocks=this.CalculateBlocks（0.FirstOrDefault（）；
}
返回块；
}
}

这是冗长的；如果可能的话，我想让它更简洁。以下是可以接受的

private Lazy<IEnumerable<int>> _blocks = 
    new Lazy<IEnumerable<int>>(() => this.CalculateBlocks(0).FirstOrDefault());

private Lazy\u块=
新的Lazy（（）=>this.CalculateBlocks（0.FirstOrDefault（））；

。。。但它没有编译

关键字“this”在静态属性、静态方法或静态字段初始值设定项中无效

所以我提出了以下建议

struct MyLazy<TResult>
{
    private bool evaluated;
    private TResult result;

    public TResult Evaluate(Func<TResult> func)
    {
        if (!evaluated)
        {
            evaluated = true;
            result = func();
        }
        return result;
    }
}

private MyLazy<IEnumerable<int>> _blocks;
public IEnumerable<int> Blocks
{
    get { return _blocks.Evaluate(() => this.CalculateBlocks(0).FirstOrDefault()); }
}

struct MyLazy
{
评估私人bool；
私有结果；
公共结果评估（Func Func）
{
如果（！已评估）
{
评估=正确；
结果=func（）；
}
返回结果；
}
}
私人MyLazy_街区；
公共可数大厦
{
获取{return _blocks.Evaluate（（）=>this.CalculateBlocks（0.FirstOrDefault（））；}
}

我最喜欢哪一种，但有更好的方法吗

---

注意-我意识到可变结构通常是邪恶的，但它们对于这一特定问题似乎非常有用。

只需在构造函数中初始化字段

public class MyClass
{
    public MyClass()
    {
        _blocks = new Lazy<IEnumerable<int>>(() => this.CalculateBlocks(0).FirstOrDefault());
    }

    private readonly Lazy<IEnumerable<int>> _blocks;
}

公共类MyClass
{
公共MyClass（）
{
_blocks=newlazy（（）=>this.CalculateBlocks（0.FirstOrDefault（））；
}
私有只读惰性块；
}

初始化实例字段时不能使用

此

，但只需在构造函数中对其进行初始化即可

private Lazy<IEnumerable<int>> _blocks;

public MyClass()
{
   _blocks = new Lazy<IEnumerable<int>>(
         () => this.CalculateBlocks(0).FirstOrDefault());
}

public IEnumerable<int> Blocks
{
    get
    {
        return _blocks.Value;
    }
}

private Lazy\u块；
公共MyClass（）
{
_块=新的惰性(
（）=>this.CalculateBlocks（0.FirstOrDefault（））；
}
公共可数大厦
{
得到
{
返回_blocks.Value；
}
}

我可以问一下，为什么ienumerable只分配了一个值吗？

CalculateBlocks

返回一个

ienumerable

这当然是正确的。不幸的是，现在我真的很恼火，所以我可能只是使用我的自定义结构。