如何封装来自 IEnumerable 的长期延迟的维护项目列表

Question

我有一个枚举需要很长时间才能获得下一个值。

我正在尝试包装该可枚举，以便获得一个缓存结果的可枚举。

我还希望它在另一个线程上进行额外的加载（报告它到达集合的末尾）。即，如果它有 10 个缓存值，并且我枚举它报告 10，然后启动一个线程来获取下一个值，因此当再次枚举时，有 11 个缓存值。

到目前为止，我所拥有的如下（在底部带有测试它的代码）：

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

namespace ConsoleApplication1
{
    public class CachedEnumerable<T> : IEnumerable<T>
    {
        public class CachedEnumerator : IEnumerator<T>
        {
            private IEnumerator<T> _UnderlyingEnumerator;

            public event EventHandler Disposed;

            public CachedEnumerator(IEnumerator<T> UnderlyingEnumerator)
            {
                _UnderlyingEnumerator = UnderlyingEnumerator;
            }

            public T Current
            {
                get { return _UnderlyingEnumerator.Current; }
            }

            public void Dispose()
            {
                _UnderlyingEnumerator.Dispose();

                if (Disposed != null)
                    Disposed(this, new EventArgs());
            }

            object System.Collections.IEnumerator.Current
            {
                get { return _UnderlyingEnumerator.Current; }
            }

            public bool MoveNext()
            {
                return _UnderlyingEnumerator.MoveNext();
            }

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

        // The slow enumerator.
        private IEnumerator<T> _SourceEnumerator;

        // Whether we're currently already getting the next item.
        private bool _GettingNextItem = false;

        // Whether we've got to the end of the source enumerator.
        private bool _EndOfSourceEnumerator = false;

        // The list of values we've got so far.
        private List<T> _CachedValues = new List<T>();

        // An object to lock against, to protect the cached value list.
        private object _CachedValuesLock = new object();

        // A reset event to indicate whether the cached list is safe, or whether we're currently enumerating over it.
        private ManualResetEvent _CachedValuesSafe = new ManualResetEvent(true);

        public CachedEnumerable(IEnumerable<T> Source)
        {
            _SourceEnumerator = Source.GetEnumerator();
        }

        private void Enum_Disposed(object sender, EventArgs e)
        {
            // The cached list is now safe (because we've finished enumerating).
            _CachedValuesSafe.Set();

            if (!_EndOfSourceEnumerator && !_GettingNextItem)
            {
                _GettingNextItem = true;

                ThreadPool.QueueUserWorkItem((SourceEnumeratorArg) =>
                {
                    var SourceEnumerator = SourceEnumeratorArg as IEnumerator<T>;

                    if (SourceEnumerator.MoveNext())
                    {
                        _CachedValuesSafe.WaitOne(); // Wait for any enumerator to finish

                        lock (_CachedValuesLock)
                        {
                            _CachedValues.Add(SourceEnumerator.Current);
                        }
                    }
                    else
                    {
                        _EndOfSourceEnumerator = true;
                    }

                    _GettingNextItem = false;

                }, _SourceEnumerator);
            }
        }

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

        public IEnumerator<T> GetEnumerator()
        {
            lock (_CachedValuesLock)
            {
                var Enum = new CachedEnumerator(_CachedValues.GetEnumerator());

                Enum.Disposed += new EventHandler(Enum_Disposed);

                _CachedValuesSafe.Reset();

                return Enum;
            }
        }
    }



    class Program
    {
        public static IEnumerable<int> SlowNumbers()
        {
            int i = 0;

            while (true)
            {
                Thread.Sleep(1000);
                yield return i++;
            }
        }

        static void Main(string[] args)
        {
            var SlowNumbersEnumerator = new CachedEnumerable<int>(SlowNumbers());

            while (true)
            {
                foreach (var i in SlowNumbersEnumerator)
                {
                    Console.WriteLine(i);
                    Thread.Sleep(100);
                }
            }
        }
    }
}

我的问题是我收到 The collection has been generated 错误，因为工作线程正在将其添加到列表中被列举。但是，通过使用 ManualResetEvent，我认为我正在防范这种情况。

我做错了什么？

Answer 1

（让我的评论成为答案，无法正确格式化评论）

1. 线程 A 正在枚举 |线程 B 处于 _CachedValuesSafe.WaitOne();
2. 线程 A 完成枚举（释放 WaitHandle）
3. 线程 A 开始新的枚举获取锁 |线程 B 想要获取锁
4. 线程 A 初始化枚举|线程 B 等待锁
5. 线程 A 从 GetEnumerator() 调用返回并释放锁 |线程 B 获取锁
6. 线程 A 正在枚举集合 |线程B执行Add，修改集合
7. 线程A枚举下一个值并抛出异常