实现不带yield 关键字的Linqs Select。无法遵循控制流程

Question

我知道有很多关于 Linq 及其内部工作原理的文章。受到 Jon Skeets EduLinq 的启发，我想揭开 Linq Operators 背后发生的事情的神秘面纱。所以我尝试做的是实现 Linqs Select() 方法，乍一看听起来很无聊。但我实际上想做的是在不使用yield 关键字的情况下实现它。

到目前为止，这就是我所得到的：

class Program
{
    static void Main(string[] args)
    {
        var list = new int[] {1, 2, 3};

        var otherList = list.MySelect(x => x.ToString()).MySelect(x => x + "test");

        foreach (var item in otherList)
        {
            Console.WriteLine(item);
        }

        Console.ReadLine();
    }
}

public static class EnumerableEx
{
    public static IEnumerable<R> MySelect<T, R>(this IEnumerable<T> sequence, Func<T, R> apply)
    {
        return new EnumerableWrapper<R, T>(sequence, apply);
    }
}

public class EnumerableWrapper<T, O> : IEnumerable<T>
{
    private readonly IEnumerable<O> _sequence;
    private readonly Func<O, T> _apply;

    public EnumerableWrapper(IEnumerable<O> sequence, Func<O, T> apply)
    {
        _sequence = sequence;
        _apply = apply;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new EnumeratorWrapper<T, O>(_sequence, _apply);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class EnumeratorWrapper<T, O> : IEnumerator<T>
{
    private readonly IEnumerator<O> _enumerator;
    private readonly Func<O, T> _apply;

    public EnumeratorWrapper(IEnumerable<O> sequence, Func<O, T> apply)
    {
        _enumerator = sequence.GetEnumerator();
        _apply = apply;
    }

    public void Dispose()
    {
    }

    public bool MoveNext()
    {
        var hasItems = _enumerator.MoveNext();
        if (hasItems)
            Current = _apply(_enumerator.Current);
        return hasItems;
    }

    public void Reset()
    {
        _enumerator.Reset();
    }

    public T Current { get; private set; }

    object IEnumerator.Current
    {
        get { return Current; }
    }
}

它似乎有效。但是，我很难遵循它的控制流程。正如你所看到的，我依赖于预测。这会导致 MoveNext() 方法中发生奇怪的事情（对我来说很奇怪！）。如果在 MoveNext() 方法的每一行中设置断点，您将看到控制流实际上在不同实例之间跳转，并且永远不会在一批中执行该方法。它的跳跃就好像它使用了不同的线程或者我们使用了yield。但归根结底，这只是一个正常的方法，所以我想知道这是怎么回事？

Answer 1

每次您对结果调用 MoveNext() 时，它都会：

• 对最终迭代器（我将其称为 Y）调用 MoveNext()，这将
• ...在前一个迭代器（我将其称为 X）上调用 MoveNext()，这将...
• 在原始迭代器上调用 MoveNext() （数组的），它将返回一个数字。
• X 中的 MoveNext() 将调用投影 x =>; x.ToString() 以便它
• 在 Y 中具有适当的 Current 成员 MoveNext() 然后将调用投影 x =>; x + "test" 对 X.Current 的结果进行测试，并将结果存储在 Y.Current 中

所以这里没有什么特别神奇的事情 - 你'我们刚刚接到了一堆电话，就像平常一样。调试体验将向您展示从一个 EnumeratorWrapper.MoveNext 到另一个的调用；唯一奇怪的跳跃是当您单步执行在 Main 方法中声明的投影时。

如果这不能解释是什么让您感到困惑，请详细说明您不理解流程的具体情况，我会尽力提供帮助。 （很高兴看到你想更多地了解所有这些事情是如何运作的。很高兴看到志同道合的人！）