Question

提供items是q LINQ表达式的结果：

var items = from item in ItemsSource.RetrieveItems()
            where ...

假设每个项目的生成需要一些不可忽略的时间。

有两种操作模式：

使用foreach将允许开始使用集合开头的项目，而不是最终可用的项目。但是，如果我们想稍后再次处理相同的集合，我们将不得不复制保存它：
```
var storedItems = new List<Item>();
foreach(var item in items){
    Process(item);
    storedItems .Add(item);
}

// Later
foreach(var item in storedItems){
    ProcessMore(item);
}
```
因为如果我们刚刚制作foreach(... in items)，那么temsSource.RetrieveItems()会再次被调用。
我们可以提前使用.ToList()，但这会迫使我们在开始处理第一项之前等待检索最后一项。

问题：是否存在IEnumerable实现，它将像常规LINQ查询结果一样首次迭代，但会在进程中实现，以便第二个foreach将迭代存储的值？

Answer 1

一个有趣的挑战，所以我必须提供自己的解决方案。事实上，我的解决方案现在很有趣，版本3.版本2是我根据Servy的反馈进行的简化。然后我意识到我的解决方案有很大的缺点。如果缓存的可枚举的第一个枚举没有完成，则不会进行缓存。许多LINQ扩展（如First和Take）只会枚举足够数量的枚举来完成工作，我不得不更新到版本3以使其与缓存一起工作。

问题是关于可枚举的后续枚举，它不涉及并发访问。不过我决定让我的解决方案线程安全。它增加了一些复杂性和一些开销，但应该允许在所有场景中使用该解决方案。

public static class EnumerableExtensions {

  public static IEnumerable<T> Cached<T>(this IEnumerable<T> source) {
    if (source == null)
      throw new ArgumentNullException("source");
    return new CachedEnumerable<T>(source);
  }

}

class CachedEnumerable<T> : IEnumerable<T> {

  readonly Object gate = new Object();

  readonly IEnumerable<T> source;

  readonly List<T> cache = new List<T>();

  IEnumerator<T> enumerator;

  bool isCacheComplete;

  public CachedEnumerable(IEnumerable<T> source) {
    this.source = source;
  }

  public IEnumerator<T> GetEnumerator() {
    lock (this.gate) {
      if (this.isCacheComplete)
        return this.cache.GetEnumerator();
      if (this.enumerator == null)
        this.enumerator = source.GetEnumerator();
    }
    return GetCacheBuildingEnumerator();
  }

  public IEnumerator<T> GetCacheBuildingEnumerator() {
    var index = 0;
    T item;
    while (TryGetItem(index, out item)) {
      yield return item;
      index += 1;
    }
  }

  bool TryGetItem(Int32 index, out T item) {
    lock (this.gate) {
      if (!IsItemInCache(index)) {
        // The iteration may have completed while waiting for the lock.
        if (this.isCacheComplete) {
          item = default(T);
          return false;
        }
        if (!this.enumerator.MoveNext()) {
          item = default(T);
          this.isCacheComplete = true;
          this.enumerator.Dispose();
          return false;
        }
        this.cache.Add(this.enumerator.Current);
      }
      item = this.cache[index];
      return true;
    }
  }

  bool IsItemInCache(Int32 index) {
    return index < this.cache.Count;
  }

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

}

扩展名使用如下（sequence是IEnumerable<T>）：

var cachedSequence = sequence.Cached();

// Pulling 2 items from the sequence.
foreach (var item in cachedSequence.Take(2))
  // ...

// Pulling 2 items from the cache and the rest from the source.
foreach (var item in cachedSequence)
  // ...

// Pulling all items from the cache.
foreach (var item in cachedSequence)
  // ...

如果只枚举枚举的部分枚举（例如cachedSequence.Take(2).ToList()），则会有轻微的泄漏。ToList使用的枚举器将被处理，但基础源枚举器不会被丢弃。这是因为如果对后续项目发出请求，则前2个项目被缓存并且源枚举器保持活动状态。在这种情况下，源枚举器仅在易于进行垃圾收集时清理（与可能的大缓存相同）。 / p>

Answer 2

查看Reactive Extentsions库 - 有一个MemoizeAll()扩展名，一旦访问它们就会缓存IEnumerable中的项目，并存储它们以供将来访问。

请参阅Bart de Smet撰写的this博客文章，了解MemoizeAll和其他Rx方法。

修改：实际上现在可以在单独的Interactive Extensions包中找到它 - 可从NuGet或Microsoft Download获取。

Answer 3

public static IEnumerable<T> SingleEnumeration<T>(this IEnumerable<T> source)
{
    return new SingleEnumerator<T>(source);
}

private class SingleEnumerator<T> : IEnumerable<T>
{
    private CacheEntry<T> cacheEntry;
    public SingleEnumerator(IEnumerable<T> sequence)
    {
        cacheEntry = new CacheEntry<T>(sequence.GetEnumerator());
    }

    public IEnumerator<T> GetEnumerator()
    {
        if (cacheEntry.FullyPopulated)
        {
            return cacheEntry.CachedValues.GetEnumerator();
        }
        else
        {
            return iterateSequence<T>(cacheEntry).GetEnumerator();
        }
    }

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

private static IEnumerable<T> iterateSequence<T>(CacheEntry<T> entry)
{
    using (var iterator = entry.CachedValues.GetEnumerator())
    {
        int i = 0;
        while (entry.ensureItemAt(i) && iterator.MoveNext())
        {
            yield return iterator.Current;
            i++;
        }
    }
}

private class CacheEntry<T>
{
    public bool FullyPopulated { get; private set; }
    public ConcurrentQueue<T> CachedValues { get; private set; }

    private static object key = new object();
    private IEnumerator<T> sequence;

    public CacheEntry(IEnumerator<T> sequence)
    {
        this.sequence = sequence;
        CachedValues = new ConcurrentQueue<T>();
    }

    /// <summary>
    /// Ensure that the cache has an item a the provided index.  If not, take an item from the 
    /// input sequence and move to the cache.
    /// 
    /// The method is thread safe.
    /// </summary>
    /// <returns>True if the cache already had enough items or 
    /// an item was moved to the cache, 
    /// false if there were no more items in the sequence.</returns>
    public bool ensureItemAt(int index)
    {
        //if the cache already has the items we don't need to lock to know we 
        //can get it
        if (index < CachedValues.Count)
            return true;
        //if we're done there's no race conditions hwere either
        if (FullyPopulated)
            return false;

        lock (key)
        {
            //re-check the early-exit conditions in case they changed while we were
            //waiting on the lock.

            //we already have the cached item
            if (index < CachedValues.Count)
                return true;
            //we don't have the cached item and there are no uncached items
            if (FullyPopulated)
                return false;

            //we actually need to get the next item from the sequence.
            if (sequence.MoveNext())
            {
                CachedValues.Enqueue(sequence.Current);
                return true;
            }
            else
            {
                FullyPopulated = true;
                return false;
            }
        }
    }
}

所以这已被编辑（基本上）以支持多线程访问。有几个线程可以请求项目，并且逐个项目，它们将被缓存。它不需要等待整个序列被迭代以使其返回缓存值。下面是一个示例程序，用于演示：

private static IEnumerable<int> interestingIntGenertionMethod(int maxValue)
{
    for (int i = 0; i < maxValue; i++)
    {
        Thread.Sleep(1000);
        Console.WriteLine("actually generating value: {0}", i);
        yield return i;
    }
}

public static void Main(string[] args)
{
    IEnumerable<int> sequence = interestingIntGenertionMethod(10)
        .SingleEnumeration();

    int numThreads = 3;
    for (int i = 0; i < numThreads; i++)
    {
        int taskID = i;
        Task.Factory.StartNew(() =>
        {
            foreach (int value in sequence)
            {
                Console.WriteLine("Task: {0} Value:{1}",
                    taskID, value);
            }
        });
    }

    Console.WriteLine("Press any key to exit...");
    Console.ReadKey(true);
}

你真的需要看到它来了解这里的力量。一旦单个线程强制生成下一个实际值，所有剩余的线程都可以立即打印该生成的值，但是如果没有要打印的线程的未缓存值，它们将全部等待。（显然线程/线程池调度可能导致一个任务需要更长的时间来打印它的值而不是需要。）

是否有IEnumerable实现只迭代它的源（例如LINQ）一次

3 个答案: