32

我很想自己弄清楚，但我想知道将带有 yield 语句的函数转换为枚举器的状态机的算法是什么？例如，C# 是如何做到这一点的：

IEnumerator<string> strings(IEnumerable<string> args)
 { IEnumerator<string> enumerator2 = getAnotherEnumerator();     
   foreach(var arg in arg) 
    { enumerator2.MoveNext();
      yield return arg+enumerator.Current;
    } 
 }

进入这个：

bool MoveNext()
 { switch (this.state)
    {
        case 0:
            this.state = -1;
            this.enumerator2 = getAnotherEnumerator();
            this.argsEnumerator = this.args.GetEnumerator();
            this.state = 1;
            while (this.argsEnumerator.MoveNext())
            {
                this.arg = this.argsEnumerator.Current;
                this.enumerator2.MoveNext();
                this.current = this.arg + this.enumerator2.Current;
                this.state = 2;
                return true;

              state1:
                this.state = 1;
            }
            this.state = -1;
            if (this.argsEnumerator != null) this.argsEnumerator.Dispose();
            break;

        case 2:
            goto state1;
    }
    return false;
}

当然，根据原始代码，结果可能会完全不同。

4

3 回答 3

60

您正在查看的特定代码示例涉及一系列转换。请注意，这是对算法的近似描述。编译器使用的实际名称和它生成的确切代码可能不同。然而，这个想法是一样的。

第一个转换是“foreach”转换，它转换了这段代码：

foreach (var x in y)
{
   //body
}

进入这段代码：

var enumerator = y.GetEnumerator();
while (enumerator.MoveNext())
{
    var x = enumerator.Current;
    //body
}

if (y != null)
{
    enumerator.Dispose();
}

第二个转换在函数体中找到所有的 yield return 语句，为每个语句分配一个数字（一个状态值），并在 yield 之后创建一个“goto 标签”。

第三个转换将方法体中的所有局部变量和函数参数提升到一个称为闭包的对象中。

鉴于您的示例中的代码，这看起来类似于：

 class ClosureEnumerable : IEnumerable<string>
 {
    private IEnumerable<string> args;
    private ClassType originalThis;
    public ClosureEnumerator(ClassType origThis, IEnumerable<string> args)
    {
        this.args = args;
        this.origianlThis = origThis;
    }
    public IEnumerator<string> GetEnumerator()
    {
        return new Closure(origThis, args);
    }
 }

class Closure : IEnumerator<string>
{
    public Closure(ClassType originalThis, IEnumerable<string> args)
    {
        state = 0;
        this.args = args;
        this.originalThis = originalThis;
    }

    private IEnumerable<string> args;
    private IEnumerator<string> enumerator2;
    private IEnumerator<string> argEnumerator;

    //- Here ClassType is the type of the object that contained the method
    //  This may be optimized away if the method does not access any 
    //  class members
    private ClassType originalThis;

    //This holds the state value.
    private int state;
    //The current value to return
    private string currentValue;

    public string Current
    {
        get 
        {
            return currentValue;
        }
    }
}

然后将方法体从原始方法移动到“Closure”内部称为 MoveNext 的方法，该方法返回一个布尔值，并实现 IEnumerable.MoveNext。对任何本地人的任何访问都通过“this”进行路由，对任何类成员的任何访问都通过 this.originalThis 进行路由。

任何“yield return expr”都被翻译成：

currentValue = expr;
state = //the state number of the yield statement;
return true;

任何 yield break 语句都被翻译成：

state = -1;
return false;

函数末尾有一个“隐式” yield break 语句。然后在过程的开头引入一个 switch 语句，它查看状态号并跳转到相关的标签。

然后将原始方法翻译成如下内容：

IEnumerator<string> strings(IEnumerable<string> args)
{
   return new ClosureEnumerable(this,args);
}

方法的状态全部被推入一个对象并且 MoveNext 方法使用 switch 语句/状态变量这一事实允许迭代器表现得好像控制在最后一次“yield return”之后立即被传递回" 下次调用“MoveNext”时声明。

然而，重要的是要指出，C# 编译器使用的转换并不是执行此操作的最佳方式。当尝试将“yield”与递归算法一起使用时，它的性能很差。有一篇很好的论文在这里概述了一种更好的方法：

http://research.microsoft.com/en-us/projects/specsharp/iterators.pdf

如果你还没有读过它，它值得一读。

于 2008-09-25T08:17:04.767 回答
8

刚刚发现了这个问题——我最近写了一篇关于它的文章。不过，我必须将此处提到的其他链接添加到文章中...

于 2008-10-07T06:40:51.510 回答
7

Raymond chen 回答了这个问题；http://blogs.msdn.com/b/oldnewthing/archive/2008/08/12/8849519.aspx

（编辑指向该系列的第 1 部分，而不是第 4 部分）

于 2008-09-25T07:20:33.917 回答