yield 如何实现延迟加载的模式？答案

【问题标题】：How yield implements the pattern of lazy loading?yield 如何实现延迟加载的模式？
【发布时间】：2011-02-14 23:08:14
【问题描述】：

yield如何实现lazy loading的模式？

【问题讨论】：

标签： c# .net orm lazy-loading yield

【解决方案1】：

yield 实现在需要之前不会到达代码。

例如这段代码：

public IEnumerable<int> GetInts()
{
    yield return 1;
    yield return 2;
    yield return 3;
}

实际上会编译成实现IEnumerable<int> 的嵌套类，GetInts() 的主体将返回该类的实例。

使用反射器可以看到：

public IEnumerable<int> GetInts()
{
    <GetInts>d__6d d__d = new <GetInts>d__6d(-2);
    d__d.<>4__this = this;
    return d__d;
}

编辑 - 添加有关GetInts 实施的更多信息：
此实现使其变得惰性的方式是基于 Enumerator MoveNext() 方法。当生成可枚举的嵌套类时（示例中为<GetInts>d__6d），它有一个状态，并且每个状态都有一个值连接（这是一个简单的情况，在更高级的情况下，将在代码达到状态时评估该值）。如果我们查看<GetInts>d__6d 的MoveNext() 代码，我们会看到状态：

private bool MoveNext()
{
    switch (this.<>1__state)
    {
        case 0:
            this.<>1__state = -1;
            this.<>2__current = 1;
            this.<>1__state = 1;
            return true;

        case 1:
            this.<>1__state = -1;
            this.<>2__current = 2;
            this.<>1__state = 2;
            return true;

        case 2:
            this.<>1__state = -1;
            this.<>2__current = 3;
            this.<>1__state = 3;
            return true;

        case 3:
            this.<>1__state = -1;
            break;
    }
    return false;
}

当枚举器被询问当前对象时，它返回连接到当前状态的对象。

为了表明代码仅在需要时才被评估，您可以查看以下示例：

[TestFixture]
public class YieldExample
{
    private int flag = 0;
    public IEnumerable<int> GetInts()
    {
        yield return 1;
        flag = 1;
        yield return 2;
        flag = 2;
        yield return 3;
        flag = 3;
    }

    [Test]
    public void Test()
    {
        int expectedFlag = 0;
        foreach (var i in GetInts())
        {
            Assert.That(flag, Is.EqualTo(expectedFlag));
            expectedFlag++;
        }

        Assert.That(flag, Is.EqualTo(expectedFlag));
    }
}

我希望它更清楚一点。我建议使用 Reflector 查看代码，并在更改“yield”代码时观察编译后的代码。

【讨论】：

@Elisha：请提供有关 GetInts() 的更多详细信息。
@masoud ramezani，添加了有关 GetInts 嵌套枚举器类的更多信息。
感谢您的完整回答。

【解决方案2】：

基本上使用yield 语句实现的迭代器被编译成一个实现state machine 的类。

如果您从未foreach（=迭代并实际使用）返回的IEnumerable<T>，则代码永远不会实际执行。如果这样做，则只执行确定要返回的下一个值所需的最少代码，仅在请求下一个值时恢复执行。

当您在调试器中单步执行此类代码时，您实际上可以看到这种行为发生。至少尝试一次：我认为看到这一步一步发生是很有启发性的。

【讨论】：

【解决方案3】：

如果您想了解更多关于编译器在使用 yield return 时所做的事情，请查看 Jon Skeet 的这篇文章：Iterator block implementation details

【讨论】：

实际上是出色的重定向。 +1