Count() 值中的 IEnumerable 批处理差异

Question

我正在尝试将IEnumerable<T> 分成相等的子集，并遇到了以下解决方案：

1. MoreLinq Nuget 库 Batch，这里详细介绍其实现：

   MoreLinq - Batch，下面贴源码：

   public static IEnumerable<TResult> Batch<TSource, TResult>(this   
     IEnumerable<TSource> source, int size,
           Func<IEnumerable<TSource>, TResult> resultSelector)
    {
       if (source == null) throw new ArgumentNullException(nameof(source));
       if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
       if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
         return BatchImpl(source, size, resultSelector);
    }
   
   private static IEnumerable<TResult> BatchImpl<TSource, TResult> (this IEnumerable<TSource> source, int       
             size,Func<IEnumerable<TSource>, TResult> resultSelector)
   {
       Debug.Assert(source != null);
       Debug.Assert(size > 0);
       Debug.Assert(resultSelector != null);
   
      TSource[] bucket = null;
      var count = 0;
   
   foreach (var item in source)
   {
       if (bucket == null)
       {
           bucket = new TSource[size];
       }
   
       bucket[count++] = item;
   
       // The bucket is fully buffered before it's yielded
       if (count != size)
       {
           continue;
       }
   
       // Select is necessary so bucket contents are streamed too
       yield return resultSelector(bucket);
   
       bucket = null;
       count = 0;
   }
   
   // Return the last bucket with all remaining elements
   if (bucket != null && count > 0)
   {
       Array.Resize(ref bucket, count);
           yield return resultSelector(bucket);
   }
   }
   

2. 以下链接提供了另一种最佳解决方案（内存效率更高）：

   IEnumerable Batching，下面贴源码：

   public static class BatchLinq
   {
        public static IEnumerable<IEnumerable<T>> CustomBatch<T>(this IEnumerable<T> source, int size)
       {
         if (size <= 0)
           throw new ArgumentOutOfRangeException("size", "Must be greater than zero.");
   
        using (IEnumerator<T> enumerator = source.GetEnumerator())
           while (enumerator.MoveNext())
              yield return TakeIEnumerator(enumerator, size);
      }
   
      private static IEnumerable<T> TakeIEnumerator<T>(IEnumerator<T> source, int size)
     {
         int i = 0;
         do
             yield return source.Current;
         while (++i < size && source.MoveNext());
     }
   }
   

两种解决方案都提供IEnumerable<IEnumerable<T>> 的最终结果。

我在以下代码中发现了差异：

var result = Fetch IEnumerable<IEnumerable<T>> 来自上述建议的任一方法

result.Count()，导致不同的结果，它对于 MoreLinq Batch 是正确的，但对于另一个不正确，即使结果正确且两者相同

考虑以下示例：

IEnumerable<int> arr = new int[10] {1,2,3,4,5,6,7,8,9,10};

For a Partition size 3

arr.Batch(3).Count(), will provide result 4 which is correct

arr.BatchLinq(3).Count(), will provide result 10 which is incorrect

即使提供的批处理结果是正确的，当我们做ToList()时，仍然是错误的，因为我们仍然在处理第二种方法中的内存流并且没有分配内存，但仍然不会出现错误的结果, 任何意见/建议

Answer 1

第二个结果返回 Count=10 的原因是因为它使用了while (enumerator.MoveNext())，这将产生 10 次并导致生成的可枚举包含 10 个可枚举而不是 3。

在引用的问题中以较高的分数https://stackoverflow.com/a/13731854/2138959 回答也为问题提供了合理的解决方案。