c# - 是否有一个 IEnumerable 实现只迭代一次它的源代码(例如 LINQ)？

Question

提供的 items 是 LINQ 表达式的结果:

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

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

两种操作模式是可能的:

1. 使用 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)，那么 ItemsSource.RetrieveItems() 将再次被调用。

2. 我们可以直接使用 .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 使用的枚举器，但不会释放底层源枚举器。这是因为前两项是如果请求后续项，源枚举器将保持事件状态。在这种情况下，源枚举器仅在符合垃圾收集条件时才被清理(这将与可能的大型缓存同时进行)。