在 C# 中实现双向枚举器

Question

有没有办法使用yield块来实现可以向后（MoveLast（））以及向前移动的IEnumerator？

Answer 1

不是直接来自迭代器块，不是。

但是，调用者始终可以缓冲结果，例如缓冲到 List 中，或者仅调用 Reverse() - 但这并不总是适用。

Answer 2

不，C# 编译器生成的状态机是严格前向的。

在很多情况下，倒退甚至没有意义。 想象一下迭代器从网络流中读取数据 - 要向后移动，它必须记住它曾经读取过的所有内容，因为它无法倒带时间并再次向网络请求数据。

（任何以某种有损方式生成数据的东西也是如此。想象一个迭代器在每次迭代中为康威的生活返回一个新板 - 有多个板可能都是前一个板，所以要倒退你必须再次记住你已经返回的内容。）

Answer 3

我知道这个线程非常旧，但值得注意的是

foreach(var item in someCollection)
{
    // Do something
}

...被编译成：

var enumerator = someCollection.GetEnumerator()
while (enumerator.MoveNext())
{
    var item = enumerator.Current;
    // Do something
}

所以如果您不介意“MoveNext”语法，您可以轻松实现 IEnumerator 并添加“MovePrevious”。 如果使用“foreach”，则无法反转方向，但如果使用 while 循环，则可以反转方向。

或者...如果您想以相反方向（不是双向）“foreach”列表，您可以利用yield 语句。

public static IEnumerable<TItem> Get<TItem>(IList<TItem> list)
{
    if (list == null)
        yield break;

    for (int i = list.Count - 1; i > -1; i--)
        yield return list[i];
}

或者...如果您想通过走很长的路线来反向进行 foreach，您可以实现自己的 IEnumerable/IEnumerator

public static class ReverseEnumerable
{
    public static IEnumerable<TItem> Get<TItem>(IList<TItem> list)
    {
        return new ReverseEnumerable<TItem>(list);
    }
}

public struct ReverseEnumerable<TItem> : IEnumerable<TItem>
{
    private readonly IList<TItem> _list;

    public ReverseEnumerable(IList<TItem> list)
    {
        this._list = list;
    }

    public IEnumerator<TItem> GetEnumerator()
    {
        if (this._list == null)
            return Enumerable.Empty<TItem>().GetEnumerator();

        return new ReverseEnumator<TItem>(this._list);
    }

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

public struct ReverseEnumator<TItem> : IEnumerator<TItem>
{
    private readonly IList<TItem> _list;
    private int _currentIndex;

    public ReverseEnumator(IList<TItem> list)
    {
        this._currentIndex = list.Count;
        this._list = list;
    }

    public bool MoveNext()
    {
        if (--this._currentIndex > -1)
            return true;

        return false;
    }

    public void Reset()
    {
        this._currentIndex = -1;
    }

    public void Dispose() { }

    public TItem Current
    {
        get
        {
            if (this._currentIndex < 0)
                return default(TItem);

            if (this._currentIndex >= this._list.Count)
                return default(TItem);

            return this._list[this._currentIndex];
        }
    }

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

Answer 4

C5 集合库 (http://www.itu.dk/research/c5/)
使用向后枚举实现集合和链表。 该项目是开源的，因此您应该能够在那里找到答案。

Answer 5

不可以。IEnumerator 的局限性之一是它保留当前状态，并且不记得之前的状态。 因此，IEnumerable 是只向前的。

如果您需要保留先前的状态，请将 IEnumerable 读入 List 或 LinkedList 并枚举这些对象。

Answer 6

实际上，似乎有一种方法描述于 加速 C# 2008< /a>. 不幸的是，两个页面在预览中不可见，并且它必须依赖于反射（其结果可以像往常一样被缓存），但您可以了解要点。

Answer 7

不会。使用 yield 会导致IEnumerable 这是单向的。