* 珠玑：用于分组的 LINQ 扩展方法

从 *.com 上抄来的，将 IEnumerable 中的元素进行切分的方法，无动态内存分配，地球上最快的实现：

 public static class LinqExtensions
     {
         /// <summary>
         /// 将 source 中的条目按照 partitionSize 指定的每组数量进行分组
         /// http://*.com/questions/3773403/linq-partition-list-into-lists-of-8-members
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="source"></param>
         /// <param name="partitionSize"></param>
         /// <returns></returns>
         public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> source, int partitionSize)
         {
             if (partitionSize <= )
             {
                 throw new ArgumentOutOfRangeException(nameof(partitionSize));
             }

             int innerListCounter = ;
             int numberOfPackets = ;
             foreach (var item in source)
             {
                 innerListCounter++;
                 if (innerListCounter == partitionSize)
                 {
                     yield return source.Skip(numberOfPackets * partitionSize).Take(partitionSize);
                     innerListCounter = ;
                     numberOfPackets++;
                 }
             }

             if (innerListCounter > )
             {
                 yield return source.Skip(numberOfPackets * partitionSize);
             }
         }

         /// <summary>
         /// 将 source 中的条目按照 numberOfChunks 参数指定的分组数进行切分
         /// http://*.com/questions/438188/split-a-collection-into-n-parts-with-linq/13744322#13744322
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="source"></param>
         /// <param name="numberOfChunks"></param>
         /// <returns></returns>
         public static IEnumerable<IEnumerable<T>> Split<T>(this ICollection<T> source, int numberOfChunks)
         {
             if (numberOfChunks <=  || numberOfChunks > source.Count)
             {
                 throw new ArgumentOutOfRangeException(nameof(numberOfChunks));
             }

             int sizePerPacket = source.Count / numberOfChunks;
             int extra = source.Count % numberOfChunks;

             for (int i = ; i < numberOfChunks - extra; i++)
             {
                 yield return source.Skip(i * sizePerPacket).Take(sizePerPacket);
             }

             int alreadyReturnedCount = (numberOfChunks - extra) * sizePerPacket;
             int toReturnCount = extra ==  ?  : (source.Count - numberOfChunks) / extra + ;
             for (int i = ; i < extra; i++)
             {
                 yield return source.Skip(alreadyReturnedCount + i * toReturnCount).Take(toReturnCount);
             }
         }

     }

两个方法以不同的形式对 IEnumerable 集合中的元素进行分组，非常有用，而且没有容器操作等动态内存分配，不可能再快了。