是否有将 IEnumerator 转换为 IEnumerable 的内置方法

Question

是否有将IEnumerator<T> 转换为IEnumerable<T> 的内置方法？

Answer 1

我能想到的最简单的转换方法是通过 yield 语句

public static IEnumerable<T> ToIEnumerable<T>(this IEnumerator<T> enumerator) {
  while ( enumerator.MoveNext() ) {
    yield return enumerator.Current;
  }
}

与列表版本相比，这具有在返回 IEnumerable 之前不枚举整个列表的优点。使用 yield 语句，您只会遍历您需要的项目，而使用列表版本，您将首先遍历列表中的所有项目，然后是您需要的所有项目。

为了更有趣，您可以将其更改为

public static IEnumerable<K> Select<K,T>(this IEnumerator<T> e, 
                                         Func<K,T> selector) {
      while ( e.MoveNext() ) {
        yield return selector(e.Current);
      }
    }

然后您就可以在您的枚举器上使用 linq，例如：

IEnumerator<T> enumerator;
var someList = from item in enumerator
               select new classThatTakesTInConstructor(item);

Answer 2

您可以使用以下有点工作。

public class FakeEnumerable<T> : IEnumerable<T> {
  private IEnumerator<T> m_enumerator;
  public FakeEnumerable(IEnumerator<T> e) {
    m_enumerator = e;
  }
  public IEnumerator<T> GetEnumerator() { 
    return m_enumerator;
  }
  // Rest omitted 
}

当人们期望对 GetEnumerator 的连续调用返回不同的枚举器而不是相同的枚举器时，这会给您带来麻烦。但是，如果它是在非常受限的情况下一次性使用，这可能会解除您的阻止。

我确实建议您尝试不要这样做，因为我认为最终它会再次困扰您。

乔纳森建议的方式是一个更安全的选择。您可以扩展枚举器并创建剩余项目的List<T>。

public static List<T> SaveRest<T>(this IEnumerator<T> e) {
  var list = new List<T>();
  while ( e.MoveNext() ) {
    list.Add(e.Current);
  }
  return list;
}

Answer 3

EnumeratorEnumerable<T>

从IEnumerator<T> 到IEnumerable<T> 的线程安全、可重置适配器

我使用 C++ forward_iterator 概念中的枚举器参数。

我同意这会导致混淆，因为太多人确实会认为枚举器是 /like/ 可枚举的，但事实并非如此。

但是，IEnumerator 包含 Reset 方法这一事实加剧了混乱。这是我对最正确实现的想法。它利用 IEnumerator.Reset() 的实现

Enumerable 和 Enumerator 之间的主要区别在于，Enumerable 可能能够同时创建多个 Enumerator。这个实现做了很多工作来确保EnumeratorEnumerable<T> 类型永远不会发生这种情况。有两个EnumeratorEnumerableModes：

• Blocking（意味着第二个调用者将简单地等到第一个枚举完成）
• NonBlocking（意味着对枚举数的第二个（并发）请求只会引发异常）

注意 1： 74 行是实现，79 行是测试代码 :)

注意 2：为了方便，我没有参考任何单元测试框架

using System;
using System.Diagnostics;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Threading;

namespace EnumeratorTests
{
    public enum EnumeratorEnumerableMode
    {
        NonBlocking,
        Blocking,
    }

    public sealed class EnumeratorEnumerable<T> : IEnumerable<T>
    {
        #region LockingEnumWrapper

        public sealed class LockingEnumWrapper : IEnumerator<T>
        {
            private static readonly HashSet<IEnumerator<T>> BusyTable = new HashSet<IEnumerator<T>>();
            private readonly IEnumerator<T> _wrap;

            internal LockingEnumWrapper(IEnumerator<T> wrap, EnumeratorEnumerableMode allowBlocking) 
            {
                _wrap = wrap;

                if (allowBlocking == EnumeratorEnumerableMode.Blocking)
                    Monitor.Enter(_wrap);
                else if (!Monitor.TryEnter(_wrap))
                    throw new InvalidOperationException("Thread conflict accessing busy Enumerator") {Source = "LockingEnumWrapper"};

                lock (BusyTable)
                {
                    if (BusyTable.Contains(_wrap))
                        throw new LockRecursionException("Self lock (deadlock) conflict accessing busy Enumerator") { Source = "LockingEnumWrapper" };
                    BusyTable.Add(_wrap);
                }

                // always implicit Reset
                _wrap.Reset();
            }

            #region Implementation of IDisposable and IEnumerator

            public void Dispose()
            {
                lock (BusyTable)
                    BusyTable.Remove(_wrap);

                Monitor.Exit(_wrap);
            }
            public bool MoveNext()      { return _wrap.MoveNext(); }
            public void Reset()         { _wrap.Reset(); }
            public T Current            { get { return _wrap.Current; } }
            object IEnumerator.Current  { get { return Current; } }

            #endregion
        }

        #endregion

        private readonly IEnumerator<T> _enumerator;
        private readonly EnumeratorEnumerableMode _allowBlocking;

        public EnumeratorEnumerable(IEnumerator<T> e, EnumeratorEnumerableMode allowBlocking)
        {
            _enumerator = e;
            _allowBlocking = allowBlocking;
        }

        private LockRecursionPolicy a;
        public IEnumerator<T> GetEnumerator()
        {
            return new LockingEnumWrapper(_enumerator, _allowBlocking);
        }

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

    class TestClass
    {
        private static readonly string World = "hello world\n";

        public static void Main(string[] args)
        {
            var master = World.GetEnumerator();
            var nonblocking = new EnumeratorEnumerable<char>(master, EnumeratorEnumerableMode.NonBlocking);
            var blocking    = new EnumeratorEnumerable<char>(master, EnumeratorEnumerableMode.Blocking);

            foreach (var c in nonblocking)  Console.Write(c); // OK (implicit Reset())
            foreach (var c in blocking)     Console.Write(c); // OK (implicit Reset())
            foreach (var c in nonblocking)  Console.Write(c); // OK (implicit Reset())
            foreach (var c in blocking)     Console.Write(c); // OK (implicit Reset())

            try
            {
                var willRaiseException = from c1 in nonblocking from c2 in nonblocking select new {c1, c2};
                Console.WriteLine("Cartesian product: {0}", willRaiseException.Count()); // RAISE
            }
            catch (Exception e) { Console.WriteLine(e); }

            foreach (var c in nonblocking)  Console.Write(c); // OK (implicit Reset())
            foreach (var c in blocking)     Console.Write(c); // OK (implicit Reset())

            try
            {
                var willSelfLock = from c1 in blocking from c2 in blocking select new { c1, c2 };
                Console.WriteLine("Cartesian product: {0}", willSelfLock.Count()); // LOCK
            }
            catch (Exception e) { Console.WriteLine(e); }

            // should not externally throw (exceptions on other threads reported to console)
            if (ThreadConflictCombinations(blocking, nonblocking))
                throw new InvalidOperationException("Should have thrown an exception on background thread");
            if (ThreadConflictCombinations(nonblocking, nonblocking))
                throw new InvalidOperationException("Should have thrown an exception on background thread");

            if (ThreadConflictCombinations(nonblocking, blocking))
                Console.WriteLine("Background thread timed out");
            if (ThreadConflictCombinations(blocking, blocking))
                Console.WriteLine("Background thread timed out");

            Debug.Assert(true); // Must be reached
        }

        private static bool ThreadConflictCombinations(IEnumerable<char> main, IEnumerable<char> other)
        {
            try
            {
                using (main.GetEnumerator())
                {
                    var bg = new Thread(o =>
                        {
                            try { other.GetEnumerator(); }
                            catch (Exception e) { Report(e); }
                        }) { Name = "background" };
                    bg.Start();

                    bool timedOut = !bg.Join(1000); // observe the thread waiting a full second for a lock (or throw the exception for nonblocking)

                    if (timedOut)
                        bg.Abort();

                    return timedOut;
                }
            } catch
            {
                throw new InvalidProgramException("Cannot be reached");
            }
        }

        static private readonly object ConsoleSynch = new Object();
        private static void Report(Exception e)
        {
            lock (ConsoleSynch)
                Console.WriteLine("Thread:{0}\tException:{1}", Thread.CurrentThread.Name, e);
        }
    }
}

注 3： 我认为线程锁定的实现（尤其是在BusyTable 附近）相当丑陋；但是，我不想求助于ReaderWriterLock(LockRecursionPolicy.NoRecursion)，也不想为SpinLock假设.Net 4.0@

Answer 4

不，IEnumerator 和 IEnumerable 完全是不同的野兽。

Answer 5

正如 Jason Watts 所说——不，不是直接的。

如果你真的想要，你可以遍历 IEnumerator，将项目放入 List，然后返回，但我猜这不是你想要做的。

你不能去那个方向的基本原因（IEnumerator 到一个 IEnumerable）是 IEnumerable 代表一个可以枚举的集合，但是 IEnumerator 是一个特定的枚举一组项目——你不能把特定的实例变回创建它的东西。

Answer 6

static class Helper
{
  public static List<T> SaveRest<T>(this IEnumerator<T> enumerator)
  {
    var list = new List<T>();
    while (enumerator.MoveNext())
    {
      list.Add(enumerator.Current);
    }
    return list;
  }
  public static ArrayList SaveRest(this IEnumerator enumerator)
  {
    var list = new ArrayList();
    while (enumerator.MoveNext())
    {
      list.Add(enumerator.Current);
    }
    return list;
  }
}

Answer 7

这是我写的一个变种...具体有点不同。我想在IEnumerable<T> 上做一个MoveNext()，检查结果，然后将所有内容滚动到一个“完整”的新IEnumerator<T> 中（这样甚至包括我已经提取的IEnumerable<T> 的元素）

// Simple IEnumerable<T> that "uses" an IEnumerator<T> that has
// already received a MoveNext(). "eats" the first MoveNext() 
// received, then continues normally. For shortness, both IEnumerable<T>
// and IEnumerator<T> are implemented by the same class. Note that if a
// second call to GetEnumerator() is done, the "real" IEnumerator<T> will
// be returned, not this proxy implementation.
public class EnumerableFromStartedEnumerator<T> : IEnumerable<T>, IEnumerator<T>
{
    public readonly IEnumerator<T> Enumerator;

    public readonly IEnumerable<T> Enumerable;

    // Received by creator. Return value of MoveNext() done by caller
    protected bool FirstMoveNextSuccessful { get; set; }

    // The Enumerator can be "used" only once, then a new enumerator
    // can be requested by Enumerable.GetEnumerator() 
    // (default = false)
    protected bool Used { get; set; }

    // The first MoveNext() has been already done (default = false)
    protected bool DoneMoveNext { get; set; }

    public EnumerableFromStartedEnumerator(IEnumerator<T> enumerator, bool firstMoveNextSuccessful, IEnumerable<T> enumerable)
    {
        Enumerator = enumerator;
        FirstMoveNextSuccessful = firstMoveNextSuccessful;
        Enumerable = enumerable;
    }

    public IEnumerator<T> GetEnumerator()
    {
        if (Used)
        {
            return Enumerable.GetEnumerator();
        }

        Used = true;
        return this;
    }

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

    public T Current
    {
        get
        {
            // There are various school of though on what should
            // happens if called before the first MoveNext() or
            // after a MoveNext() returns false. We follow the 
            // "return default(TInner)" school of thought for the
            // before first MoveNext() and the "whatever the 
            // Enumerator wants" for the after a MoveNext() returns
            // false
            if (!DoneMoveNext)
            {
                return default(T);
            }

            return Enumerator.Current;
        }
    }

    public void Dispose()
    {
        Enumerator.Dispose();
    }

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

    public bool MoveNext()
    {
        if (!DoneMoveNext)
        {
            DoneMoveNext = true;
            return FirstMoveNextSuccessful;
        }

        return Enumerator.MoveNext();
    }

    public void Reset()
    {
        // This will 99% throw :-) Not our problem.
        Enumerator.Reset();

        // So it is improbable we will arrive here
        DoneMoveNext = true;
    }
}

用途：

var enumerable = someCollection<T>;

var enumerator = enumerable.GetEnumerator();
bool res = enumerator.MoveNext();
// do whatever you want with res/enumerator.Current

var enumerable2 = new EnumerableFromStartedEnumerator<T>(enumerator, res, enumerable);

现在，将通过枚举器enumerator 给出将被请求到enumerable2 的第一个GetEnumerator()。从第二个开始，enumerable.GetEnumerator() 将被使用。

Answer 8

使用 Factory 以及修复 JaredPar's answer 中缓存的 IEnumerator 问题的解决方案允许更改枚举方式。

考虑一个简单的例子：我们想要自定义List<T> 包装器，它允许以相反的顺序枚举以及默认枚举。 List<T> 已经实现了IEnumerator 用于默认枚举，我们只需要创建以相反顺序枚举的IEnumerator。 （我们不会使用List<T>.AsEnumerable().Reverse()，因为它会枚举列表两次）

public enum EnumerationType {
    Default = 0,
    Reverse
}

public class CustomList<T> : IEnumerable<T> {
    private readonly List<T> list;

    public CustomList(IEnumerable<T> list) => this.list = new List<T>(list);
    
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    
    //Default IEnumerable method will return default enumerator factory
    public IEnumerator<T> GetEnumerator() 
        => GetEnumerable(EnumerationType.Default).GetEnumerator();

    public IEnumerable<T> GetEnumerable(EnumerationType enumerationType)
        => enumerationType switch {
            EnumerationType.Default => new DefaultEnumeratorFactory(list),
            EnumerationType.Reverse => new ReverseEnumeratorFactory(list)
        };
    
    //Simple implementation of reverse list enumerator
    private class ReverseEnumerator : IEnumerator<T> {
        private readonly List<T> list;
        private int index;

        internal ReverseEnumerator(List<T> list) {
            this.list = list;
            index = list.Count-1;
            Current = default;
        }

        public void Dispose() { }

        public bool MoveNext() {
            if(index >= 0) {
                Current = list[index];
                index--;
                return true;
            }
            Current = default;
            return false;
        }

        public T Current { get; private set; }

        object IEnumerator.Current => Current;

        void IEnumerator.Reset() {
            index = list.Count - 1;
            Current = default;
        }
    }
    
    private abstract class EnumeratorFactory : IEnumerable<T> {
        protected readonly List<T> List;
        protected EnumeratorFactory(List<T> list) => List = list;
        
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        
        public abstract IEnumerator<T> GetEnumerator();
    }


    private class DefaultEnumeratorFactory : EnumeratorFactory {
        
        public DefaultEnumeratorFactory(List<T> list) : base(list) { }
        
        //Default enumerator is already implemented in List<T>
        public override IEnumerator<T> GetEnumerator() => List.GetEnumerator();
    }


    private class ReverseEnumeratorFactory : EnumeratorFactory {

        public ReverseEnumeratorFactory(List<T> list) : base(list) { }

        public override IEnumerator<T> GetEnumerator() => new ReverseEnumerator(List);
    }
    
}

Answer 9

这里的其他答案……很奇怪。 IEnumerable<T> 只有一种方法，GetEnumerator()。而IEnumerable<T> 必须实现IEnumerable，它也只有一个方法GetEnumerator()（区别在于T 上一个是通用的，而另一个不是）。所以应该清楚如何将IEnumerator<T> 变成IEnumerable<T>：

    // using modern expression-body syntax
    public class IEnumeratorToIEnumerable<T> : IEnumerable<T>
    {
        private readonly IEnumerator<T> Enumerator;

        public IEnumeratorToIEnumerable(IEnumerator<T> enumerator) =>
            Enumerator = enumerator;

        public IEnumerator<T> GetEnumerator() => Enumerator;
        IEnumerator IEnumerable.GetEnumerator() => Enumerator;
    }

    foreach (var foo in new IEnumeratorToIEnumerable<Foo>(fooEnumerator))
        DoSomethingWith(foo);

    // and you can also do:

    var fooEnumerable = new IEnumeratorToIEnumerable<Foo>(fooEnumerator);

    foreach (var foo in fooEnumerable)
        DoSomethingWith(foo);

    // Some IEnumerators automatically repeat after MoveNext() returns false,
    // in which case this is a no-op, but generally it's required.
    fooEnumerator.Reset();

    foreach (var foo in fooEnumerable)
        DoSomethingElseWith(foo);

但是，这些都不需要，因为 IEnumerator<T> 不附带 IEnumerable<T> 从其 GetEnumerator 方法返回它的实例是不寻常的。如果您正在编写自己的IEnumerator<T>，您当然应该提供IEnumerable<T>。实际上恰恰相反...... IEnumerator<T> 旨在成为一个私有类，它迭代实现 IEnumerable<T> 的公共类的实例。