IEnumerable<T> 如何在后台工作

Question

我正在探索IEnumerable<T> 界面的更深入的功能。

基本上，它作为执行的中间步骤。例如，如果你写：

IEnumerable<int> temp = new int[]{1,2,3}.Select(x => 2*x);

Select 函数的结果将不会被计算（枚举），直到使用 temp 完成某些操作以允许它（例如 List<int> list = temp.ToList()）。

然而，令我困惑的是，由于IEnumerable<T> 是一个接口，根据定义，它不能被实例化。那么，实际项目（在示例中为 2*x 项目）所在的集合是什么？

此外，如果我们写成 IEnumerable<int> temp = Enumerable.Repeat(1, 10);，那么存储 1 的底层集合是什么（数组、列表、其他）？

我似乎找不到关于这个接口的实际实现及其功能的彻底（更深入）的解释（例如，如果有一个底层集合，yield 关键字是如何工作的）。

基本上，我要求的是对IEnumerable<T> 的功能进行更详细的解释。

Answer 1

实施应该无关紧要。所有这些 (LINQ) 方法都返回 IEnumerable<T>，接口成员是您可以访问的唯一成员，应该足以使用它们。

但是，如果你真的需要知道，你可以在http://sourceof.net 上找到实际的实现。

• Enumerable.cs

但是，对于某些方法，您将无法找到明确的类声明，因为其中一些使用yield return，这意味着编译器在编译期间会生成正确的类（带有状态机）。例如Enumerable.Repeat 就是这样实现的：

public static IEnumerable<int> Range(int start, int count) {
    long max = ((long)start) + count - 1;
    if (count < 0 || max > Int32.MaxValue)
        throw Error.ArgumentOutOfRange("count");
    return RangeIterator(start, count); 
}

static IEnumerable<int> RangeIterator(int start, int count) {
    for (int i = 0; i < count; i++)
        yield return start + i;
}

您可以在 MSDN 上阅读更多相关信息：Iterators (C# and Visual Basic)

Answer 2

并非所有实现IEnumerable 的对象都以某种方式延迟执行。接口的 API 使延迟执行成为可能，但它并不要求它。同样有一些实现不以任何方式延迟执行。

那么，实际项目（在示例中为 2*x 个项目）所在的集合是什么？

没有。每当请求下一个值时，它按需计算一个值，将其提供给调用者，然后忘记该值。它不会将其存储在其他任何地方。

此外，如果我们写成IEnumerable<int> temp = Enumerable.Repeat(1, 10);，那么存储 1 的底层集合是什么（数组、列表、其他）？

不会有一个。 当您要求下一个值时，它会立即计算每个新值，之后它不会记住它。它只存储足够的信息来计算下一个值，这意味着它只需要存储元素和剩余的值的数量。

虽然实际的 .NET 实现将使用更简洁的方法来创建这种类型，但创建一个延迟执行的枚举并不是特别困难。这样做，即使是漫长的道路也比困难更乏味。您只需在迭代器的 MoveNext 方法中计算下一个值。在您询问的示例中，Repeat，这很容易，因为您只需要计算 if 还有另一个值，而不是它是什么：

public class Repeater<T> : IEnumerator<T>
{
    private int count;
    private T element;

    public Repeater(T element, int count)
    {
        this.element = element;
        this.count = count;
    }
    public T Current { get { return element; } }

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

    public void Dispose() { }

    public bool MoveNext()
    {
        if (count > 0)
        {
            count--;
            return true;
        }
        else
            return false;
    }

    public void Reset()
    {
        throw new NotSupportedException();
    }
}

（我省略了仅返回此类型的新实例的 IEnumerable 类型，或创建该可枚举的新实例的静态 Repeat 方法。那里没有什么特别有趣的东西。 )

一个更有趣的例子是Count：

public class Counter : IEnumerator<int>
{
    private int remaining;

    public Counter(int start, int count)
    {
        Current = start;
        this.remaining = count;
    }
    public int Current { get; private set; }

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

    public void Dispose() { }

    public bool MoveNext()
    {
        if (remaining > 0)
        {
            remaining--;
            Current++;
            return true;
        }
        else
            return false;
    }

    public void Reset()
    {
        throw new NotSupportedException();
    }
}

这里我们不仅计算我们是否有另一个值，而且每次向我们请求一个新值时，下一个值是什么。

Answer 3

那么，实际项目（在示例中为 2*x 个项目）所在的集合是什么？

它不在任何地方。当您迭代时，有些代码会“按需”生成单个项目，但 2*x 数字不是预先计算的。它们也不会存储在任何地方，除非您致电 ToList 或 ToArray。

此外，如果我们要编写 IEnumerable temp = Enumerable.Repeat(1, 10);，那么存储 1 的底层集合是什么（数组、列表等）？

这里是同样的图片：IEnumerable 的返回实现不是公开的，它按需返回其项目，而不会将它们存储在任何地方。

C# 编译器提供了一种方便的方法来实现IEnumerable，而无需为其定义类。您只需将方法返回类型声明为IEnumerable<T>，并根据需要使用yield return 提供值。