Split List into Sublists with LINQ

Question

Is there any way I can separate a List lt SomeObject gt  into several separate lists of SomeObject  using the item index as the delimiter of each split   Let me exemplify   I have a List lt SomeObject gt  and I need a List lt List lt SomeObject gt  gt  or List lt SomeObject gt     so that each of these resulting lists will contain a group of 3 items of the original list  sequentially    eg     Original List   a  g  e  w  p  s  q  f  x  y  i  m  c  Resulting lists   a  g  e    w  p  s    q  f  x    y  i  m    c    I d also need the resulting lists size to be a parameter of this function

User · Answer

There is no way to combine all desirable features like full lazyness, no copying, full generality and safety in one solution. The most fundamental reason is that it cannot be guaranteed that the input is not mutated before the chunks are accessed. Assume that we have a function of the following signature:

public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunkSize)
{
    // Some implementation
}

Then the following way to use it is problematic:

var myList = new List<int>()
{
    1,2,3,4
};
var myChunks = myList.Chunk(2);
myList.RemoveAt(0);
var firstChunk = myChunks.First();    
Console.WriteLine("First chunk:" + String.Join(',', firstChunk));
myList.RemoveAt(0);
var secondChunk = myChunks.Skip(1).First();
Console.WriteLine("Second chunk:" + String.Join(',', secondChunk));
// What outputs do we see for first and second chunk? Probably not what you would expect...

Depending on the specific implementation the code will either fail with a runtime error or produce unintuitive results.

So, at least one of the properties need to be weakened. If you want a bullet-proof lazy solution you need to restrict your input type to an immutable type and even then it is not straightforward to cover up all use cases. If you have control of the usage, you could, however, still opt for the most general solution, as long as you make sure that it is used in a way that works. Otherwise, you might drop the lazyness and accept some amount of copying.

In the end, it all depends on your use case and requirements which solution is the best choice for you.

User · Answer

You could use a number of queries that use Take and Skip  but that would add too many iterations on the original list  I believe  Rather  I think you should create an iterator of your own  like so  public static IEnumerable lt IEnumerable lt T gt  gt  GetEnumerableOfEnumerables lt T gt     IEnumerable lt T gt  enumerable  int groupSize          The list to return     List lt T gt  list   new List lt T gt  groupSize          Cycle through all of the items     foreach  T item in enumerable               Add the item       list Add item            If the list has the number of elements  return that       if  list Count    groupSize                   Return the list         yield return list             Set the list to a new list         list   new List lt T gt  groupSize                      Return the remainder if there is any     if  list Count    0               Return the list       yield return list          You can then call this and it is LINQ enabled so you can perform other operations on the resulting sequences   In light of Sam s answer  I felt there was an easier way to do this without   Iterating through the list again  which I didn t do originally  Materializing the items in groups before releasing the chunk  for large chunks of items  there would be memory issues  All of the code that Sam posted  That said  here s another pass  which I ve codified in an extension method to IEnumerable lt T gt  called Chunk  public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source       int chunkSize           Validate parameters      if  source    null  throw new ArgumentNullException nameof source        if  chunkSize  lt   0  throw new ArgumentOutOfRangeException nameof chunkSize            quot The chunkSize parameter must be a positive value  quot            Call the internal implementation      return source ChunkInternal chunkSize      Nothing surprising up there  just basic error checking  Moving on to ChunkInternal  private static IEnumerable lt IEnumerable lt T gt  gt  ChunkInternal lt T gt       this IEnumerable lt T gt  source  int chunkSize           Validate parameters      Debug Assert source    null       Debug Assert chunkSize  gt  0           Get the enumerator   Dispose of when done      using  IEnumerator lt T gt  enumerator   source GetEnumerator        do                  Move to the next element   If there s nothing left            then get out          if   enumerator MoveNext    yield break              Return the chunked sequence          yield return ChunkSequence enumerator  chunkSize         while  true      Basically  it gets the IEnumerator lt T gt  and manually iterates through each item   It checks to see if there any items currently to be enumerated   After each chunk is enumerated through  if there aren t any items left  it breaks out  Once it detects there are items in the sequence  it delegates the responsibility for the inner IEnumerable lt T gt  implementation to ChunkSequence  private static IEnumerable lt T gt  ChunkSequence lt T gt  IEnumerator lt T gt  enumerator       int chunkSize           Validate parameters      Debug Assert enumerator    null       Debug Assert chunkSize  gt  0           The count      int count   0          There is at least one item   Yield and then continue      do                  Yield the item          yield return enumerator Current        while    count  lt  chunkSize  amp  amp  enumerator MoveNext        Since MoveNext was already called on the IEnumerator lt T gt  passed to ChunkSequence  it yields the item returned by Current and then increments the count  making sure never to return more than chunkSize items and moving to the next item in the sequence after every iteration  but short-circuited if the number of items yielded exceeds the chunk size   If there are no items left  then the InternalChunk method will make another pass in the outer loop  but when MoveNext is called a second time  it will still return false  as per the documentation  emphasis mine    If MoveNext passes the end of the collection  the enumerator is positioned after the last element in the collection and MoveNext returns false  When the enumerator is at this position  subsequent calls to MoveNext also return false until Reset is called   At this point  the loop will break  and the sequence of sequences will terminate  This is a simple test  static void Main         string s    quot agewpsqfxyimc quot        int count   0          Group by three      foreach  IEnumerable lt char gt  g in s Chunk 3                    Print out the group          Console Write  quot Group   0  -  quot     count               Print the items          foreach  char c in g                           Print the item              Console Write c    quot    quot                          Finish the line          Console WriteLine             Output  Group  1 - a  g  e  Group  2 - w  p  s  Group  3 - q  f  x  Group  4 - y  i  m  Group  5 - c   An important note  this will not work if you don t drain the entire child sequence or break at any point in the parent sequence   This is an important caveat  but if your use case is that you will consume every element of the sequence of sequences  then this will work for you  Additionally  it will do strange things if you play with the order  just as Sam s did at one point

User · Answer

So performatic as the Sam Saffron s approach   public static IEnumerable lt IEnumerable lt T gt  gt  Batch lt T gt  this IEnumerable lt T gt  source  int size        if  source    null  throw new ArgumentNullException nameof source        if  size  lt   0  throw new ArgumentOutOfRangeException nameof size    Size must be greater than zero          return BatchImpl source  size  TakeWhile x   gt  x Any        static IEnumerable lt IEnumerable lt T gt  gt  BatchImpl lt T gt  this IEnumerable lt T gt  source  int size        var values   new List lt T gt         var group   1      var disposed   false      var e   source GetEnumerator         try               while   disposed                        yield return GetBatch e  values  group  size       gt    e Dispose    disposed   true                  group                        finally               if   disposed              e Dispose             static IEnumerable lt T gt  GetBatch lt T gt  IEnumerator lt T gt  e  List lt T gt  values  int group  int size  Action dispose        var min    group - 1    size   1      var max   group   size      var hasValue   false       while  values Count  lt  min  amp  amp  e MoveNext                  values Add e Current              for  var i   min  i  lt   max  i                  if  i  lt   values Count                        hasValue   true                    else if  hasValue   e MoveNext                          values Add e Current                     else                       dispose                       if  hasValue              yield return values i - 1           else             yield break

User · Answer

What about this one   var input   new List lt string gt     a    g    e    w    p    s    q    f    x    y    i    m    c     var k   3  var res   Enumerable Range 0   input Count - 1    k   1                       Select i   gt  input GetRange i   k  Math Min k  input Count - i   k                         ToList      As far as I know  GetRange   is linear in terms of number of items taken  So this should perform well

User · Answer

It s an old solution but I had a different approach  I use Skip to move to desired offset and Take to extract desired number of elements   public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source                                                      int chunkSize        if  chunkSize  lt   0          throw new ArgumentOutOfRangeException    nameof chunkSize   should be  gt  0         var nbChunks    int Math Ceiling  double source Count   chunkSize        return Enumerable Range 0  nbChunks                        Select chunkNb   gt  source Skip chunkNb chunkSize                        Take chunkSize

User · Answer

If the source collection implements IList  lt  T  gt   random access by index  we could use the below approach  It only fetches the elements when they are really accessed  so this is particularly useful for lazily-evaluated collections  Similar to unbounded IEnumerable lt  T  gt   but for IList lt  T  gt       public static IEnumerable lt IEnumerable lt T gt  gt  Chunkify lt T gt  this IList lt T gt  src  int chunkSize                if  src    null  throw new ArgumentNullException nameof src            if  chunkSize  lt  1  throw new ArgumentOutOfRangeException nameof chunkSize     quot must be  gt  0  got  chunkSize  quot             for var ci   0  ci  lt   src Count chunkSize  ci                 yield return Window src  ci chunkSize  Math Min  ci 1  chunkSize  src Count -1                        private static IEnumerable lt T gt  Window lt T gt  IList lt T gt  src  int startIdx  int endIdx                Console WriteLine   quot window  startIdx  -  endIdx  quot            while startIdx  lt   endIdx               yield return src startIdx

User · Answer

You could use a number of queries that use Take and Skip  but that would add too many iterations on the original list  I believe  Rather  I think you should create an iterator of your own  like so  public static IEnumerable lt IEnumerable lt T gt  gt  GetEnumerableOfEnumerables lt T gt     IEnumerable lt T gt  enumerable  int groupSize          The list to return     List lt T gt  list   new List lt T gt  groupSize          Cycle through all of the items     foreach  T item in enumerable               Add the item       list Add item            If the list has the number of elements  return that       if  list Count    groupSize                   Return the list         yield return list             Set the list to a new list         list   new List lt T gt  groupSize                      Return the remainder if there is any     if  list Count    0               Return the list       yield return list          You can then call this and it is LINQ enabled so you can perform other operations on the resulting sequences   In light of Sam s answer  I felt there was an easier way to do this without   Iterating through the list again  which I didn t do originally  Materializing the items in groups before releasing the chunk  for large chunks of items  there would be memory issues  All of the code that Sam posted  That said  here s another pass  which I ve codified in an extension method to IEnumerable lt T gt  called Chunk  public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source       int chunkSize           Validate parameters      if  source    null  throw new ArgumentNullException nameof source        if  chunkSize  lt   0  throw new ArgumentOutOfRangeException nameof chunkSize            quot The chunkSize parameter must be a positive value  quot            Call the internal implementation      return source ChunkInternal chunkSize      Nothing surprising up there  just basic error checking  Moving on to ChunkInternal  private static IEnumerable lt IEnumerable lt T gt  gt  ChunkInternal lt T gt       this IEnumerable lt T gt  source  int chunkSize           Validate parameters      Debug Assert source    null       Debug Assert chunkSize  gt  0           Get the enumerator   Dispose of when done      using  IEnumerator lt T gt  enumerator   source GetEnumerator        do                  Move to the next element   If there s nothing left            then get out          if   enumerator MoveNext    yield break              Return the chunked sequence          yield return ChunkSequence enumerator  chunkSize         while  true      Basically  it gets the IEnumerator lt T gt  and manually iterates through each item   It checks to see if there any items currently to be enumerated   After each chunk is enumerated through  if there aren t any items left  it breaks out  Once it detects there are items in the sequence  it delegates the responsibility for the inner IEnumerable lt T gt  implementation to ChunkSequence  private static IEnumerable lt T gt  ChunkSequence lt T gt  IEnumerator lt T gt  enumerator       int chunkSize           Validate parameters      Debug Assert enumerator    null       Debug Assert chunkSize  gt  0           The count      int count   0          There is at least one item   Yield and then continue      do                  Yield the item          yield return enumerator Current        while    count  lt  chunkSize  amp  amp  enumerator MoveNext        Since MoveNext was already called on the IEnumerator lt T gt  passed to ChunkSequence  it yields the item returned by Current and then increments the count  making sure never to return more than chunkSize items and moving to the next item in the sequence after every iteration  but short-circuited if the number of items yielded exceeds the chunk size   If there are no items left  then the InternalChunk method will make another pass in the outer loop  but when MoveNext is called a second time  it will still return false  as per the documentation  emphasis mine    If MoveNext passes the end of the collection  the enumerator is positioned after the last element in the collection and MoveNext returns false  When the enumerator is at this position  subsequent calls to MoveNext also return false until Reset is called   At this point  the loop will break  and the sequence of sequences will terminate  This is a simple test  static void Main         string s    quot agewpsqfxyimc quot        int count   0          Group by three      foreach  IEnumerable lt char gt  g in s Chunk 3                    Print out the group          Console Write  quot Group   0  -  quot     count               Print the items          foreach  char c in g                           Print the item              Console Write c    quot    quot                          Finish the line          Console WriteLine             Output  Group  1 - a  g  e  Group  2 - w  p  s  Group  3 - q  f  x  Group  4 - y  i  m  Group  5 - c   An important note  this will not work if you don t drain the entire child sequence or break at any point in the parent sequence   This is an important caveat  but if your use case is that you will consume every element of the sequence of sequences  then this will work for you  Additionally  it will do strange things if you play with the order  just as Sam s did at one point

User · Answer

I wrote a Clump extension method several years ago  Works great  and is the fastest implementation here   P       lt summary gt      Clumps items into same size lots       lt  summary gt       lt typeparam name  T  gt  lt  typeparam gt       lt param name  source  gt The source list of items  lt  param gt       lt param name  size  gt The maximum size of the clumps to make  lt  param gt       lt returns gt A list of list of items  where each list of items is no bigger than the size given  lt  returns gt  public static IEnumerable lt IEnumerable lt T gt  gt  Clump lt T gt  this IEnumerable lt T gt  source  int size        if  source    null          throw new ArgumentNullException  source        if  size  lt  1          throw new ArgumentOutOfRangeException  size    size must be greater than 0         return ClumpIterator lt T gt  source  size      private static IEnumerable lt IEnumerable lt T gt  gt  ClumpIterator lt T gt  IEnumerable lt T gt  source  int size        Debug Assert source    null   source is null          T   items   new T size       int count   0      foreach  var item in source                items count    item          count             if  count    size                        yield return items              items   new T size               count   0                      if  count  gt  0                if  count    size              yield return items          else                       T   tempItems   new T count               Array Copy items  tempItems  count               yield return tempItems

User · Answer

I wrote a Clump extension method several years ago  Works great  and is the fastest implementation here   P       lt summary gt      Clumps items into same size lots       lt  summary gt       lt typeparam name  T  gt  lt  typeparam gt       lt param name  source  gt The source list of items  lt  param gt       lt param name  size  gt The maximum size of the clumps to make  lt  param gt       lt returns gt A list of list of items  where each list of items is no bigger than the size given  lt  returns gt  public static IEnumerable lt IEnumerable lt T gt  gt  Clump lt T gt  this IEnumerable lt T gt  source  int size        if  source    null          throw new ArgumentNullException  source        if  size  lt  1          throw new ArgumentOutOfRangeException  size    size must be greater than 0         return ClumpIterator lt T gt  source  size      private static IEnumerable lt IEnumerable lt T gt  gt  ClumpIterator lt T gt  IEnumerable lt T gt  source  int size        Debug Assert source    null   source is null          T   items   new T size       int count   0      foreach  var item in source                items count    item          count             if  count    size                        yield return items              items   new T size               count   0                      if  count  gt  0                if  count    size              yield return items          else                       T   tempItems   new T count               Array Copy items  tempItems  count               yield return tempItems

User · Answer

I think the following suggestion would be the fastest  I am sacrificing the lazyness of the source Enumerable for the ability to use Array Copy and knowing ahead of the time the length of each of my sublists   public static IEnumerable lt T   gt  Chunk lt T gt  this IEnumerable lt T gt  items  int size        T   array   items as T      items ToArray        for  int i   0  i  lt  array Length  i  size                T   chunk   new T Math Min size  array Length - i            Array Copy array  i  chunk  0  chunk Length           yield return chunk

User · Answer

Another way is using Rx Buffer operator    using System Linq    using System Reactive Linq    using System Reactive Threading Tasks   var observableBatches   anAnumerable ToObservable   Buffer size    var batches   aList ToObservable   Buffer size  ToList   ToTask   GetAwaiter   GetResult

User · Answer

System Interactive provides Buffer   for this purpose  Some quick testing shows performance is similar to Sam s solution

User · Answer

Using modular partitioning   public IEnumerable lt IEnumerable lt string gt  gt  Split IEnumerable lt string gt  input  int chunkSize        var chunks    int Math Ceiling  double input Count      double chunkSize       return Enumerable Range 0  chunks  Select id   gt  input Where s   gt  s GetHashCode     chunks    id

User · Answer

I took the primary answer and made it to be an IOC container to determine where to split   For who is really looking to only split on 3 items  in reading this post while searching for an answer     This method allows one to split on any type of item as needed   public static List lt List lt T gt  gt  SplitOn lt T gt  List lt T gt  main  Func lt T  bool gt  splitOn        int groupIndex   0       return main Select  item   gt  new                                                                 Group    splitOn Invoke item      groupIndex   groupIndex                                   Value   item                                                   GroupBy  it2   gt  it2 Group                   Select x   gt  x Select v   gt  v Value  ToList                     ToList          So for the OP the code would be  var it   new List lt string gt                              a    g    e    w    p    s    q    f    x    y    i    m    c      int index   0   var result   SplitOn it   itm    gt   index     3     0

User · Answer

In general the approach suggested by CaseyB works fine  in fact if you are passing in a List lt T gt  it is hard to fault it  perhaps I would change it to   public static IEnumerable lt IEnumerable lt T gt  gt  ChunkTrivialBetter lt T gt  this IEnumerable lt T gt  source  int chunksize       var pos   0      while  source Skip pos  Any               yield return source Skip pos  Take chunksize         pos    chunksize           Which will avoid massive call chains  Nonetheless  this approach has a general flaw  It materializes two enumerations per chunk  to highlight the issue try running    foreach  var item in Enumerable Range 1  int MaxValue  Chunk 8  Skip 100000  First         Console WriteLine item        wait forever    To overcome this we can try Cameron s approach  which passes the above test in flying colors as it only walks the enumeration once    Trouble is that it has a different flaw  it materializes every item in each chunk  the trouble with that approach is that you run high on memory    To illustrate that try running   foreach  var item in Enumerable Range 1  int MaxValue                  Select x   gt  x   new string  x   100000                   Clump 10000  Skip 100  First         Console Write            OutOfMemoryException   Finally  any implementation should be able to handle out of order iteration of chunks  for example   Enumerable Range 1 3  Chunk 2  Reverse   ToArray      should return  3   1 2    Many highly optimal solutions like my first revision of this answer failed there  The same issue can be seen in casperOne s optimized answer   To address all these issues you can use the following   namespace ChunkedEnumerator       public static class Extensions                class ChunkedEnumerable lt T gt    IEnumerable lt T gt                        class ChildEnumerator   IEnumerator lt T gt                                ChunkedEnumerable lt T gt  parent                  int position                  bool done   false                  T current                    public ChildEnumerator ChunkedEnumerable lt T gt  parent                                        this parent   parent                      position   -1                      parent wrapper AddRef                                       public T Current                                       get                                               if  position    -1    done                                                        throw new InvalidOperationException                                                      return current                                                            public void Dispose                                         if   done                                                done   true                          parent wrapper RemoveRef                                                             object System Collections IEnumerator Current                                       get   return Current                                       public bool MoveNext                                         position                         if  position   1  gt  parent chunkSize                                                done   true                                             if   done                                                done    parent wrapper Get position   parent start  out current                                              return  done                                      public void Reset                                            per http   msdn microsoft com en-us library system collections ienumerator reset aspx                     throw new NotSupportedException                                                 EnumeratorWrapper lt T gt  wrapper              int chunkSize              int start               public ChunkedEnumerable EnumeratorWrapper lt T gt  wrapper  int chunkSize  int start                                this wrapper   wrapper                  this chunkSize   chunkSize                  this start   start                             public IEnumerator lt T gt  GetEnumerator                                 return new ChildEnumerator this                              System Collections IEnumerator System Collections IEnumerable GetEnumerator                                 return GetEnumerator                                      class EnumeratorWrapper lt T gt                        public EnumeratorWrapper  IEnumerable lt T gt  source                                SourceEumerable   source                            IEnumerable lt T gt  SourceEumerable  get  set                Enumeration currentEnumeration               class Enumeration                               public IEnumerator lt T gt  Source   get  set                    public int Position   get  set                    public bool AtEnd   get  set                               public bool Get int pos  out T item                                  if  currentEnumeration    null  amp  amp  currentEnumeration Position  gt  pos                                        currentEnumeration Source Dispose                        currentEnumeration   null                                     if  currentEnumeration    null                                        currentEnumeration   new Enumeration   Position   -1  Source   SourceEumerable GetEnumerator    AtEnd   false                                       item   default T                   if  currentEnumeration AtEnd                                        return false                                     while currentEnumeration Position  lt  pos                                         currentEnumeration AtEnd    currentEnumeration Source MoveNext                        currentEnumeration Position                         if  currentEnumeration AtEnd                                                 return false                                                            item   currentEnumeration Source Current                   return true                             int refs   0                  needed for dispose semantics              public void AddRef                                 refs                               public void RemoveRef                                 refs--                  if  refs    0  amp  amp  currentEnumeration    null                                        var copy   currentEnumeration                      currentEnumeration   null                      copy Source Dispose                                                       public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source  int chunksize                        if  chunksize  lt  1  throw new InvalidOperationException                 var wrapper    new EnumeratorWrapper lt T gt  source                int currentPos   0              T ignore              try                               wrapper AddRef                    while  wrapper Get currentPos  out ignore                                         yield return new ChunkedEnumerable lt T gt  wrapper  chunksize  currentPos                       currentPos    chunksize                                              finally                               wrapper RemoveRef                                       class Program               static void Main string   args                        int i   10              foreach  var group in Enumerable Range 1  int MaxValue  Skip 10000000  Chunk 3                                 foreach  var n in group                                        Console Write n                       Console Write                                         Console WriteLine                    if  i--    0  break                              var stuffs   Enumerable Range 1  10  Chunk 2  ToArray                 foreach  var idx in new     3 2 1                                 Console Write  idx     idx                         foreach  var n in stuffs idx                                         Console Write n                       Console Write                                         Console WriteLine                                   10000001 10000002 10000003 10000004 10000005 10000006 10000007 10000008 10000009 10000010 10000011 10000012 10000013 10000014 10000015 10000016 10000017 10000018 10000019 10000020 10000021 10000022 10000023 10000024 10000025 10000026 10000027 10000028 10000029 10000030 10000031 10000032 10000033 idx 3 7 8 idx 2 5 6 idx 1 3 4                              Console ReadKey                           There is also a round of optimisations you could introduce for out-of-order iteration of chunks  which is out of scope here    As to which method you should choose  It totally depends on the problem you are trying to solve  If you are not concerned with the first flaw the simple answer is incredibly appealing   Note as with most methods  this is not safe for multi threading  stuff can get weird if you wish to make it thread safe you would need to amend EnumeratorWrapper

User · Answer

This is an old question but this is what I ended up with  it enumerates the enumerable only once  but does create lists for each of the partitions  It doesn t suffer from unexpected behavior when ToArray   is called as some of the implementations do       public static IEnumerable lt IEnumerable lt T gt  gt  Partition lt T gt  IEnumerable lt T gt  source  int chunkSize                if  source    null                        throw new ArgumentNullException  source                       if  chunkSize  lt  1                        throw new ArgumentException  Invalid chunkSize      chunkSize                      using  IEnumerator lt T gt  sourceEnumerator   source GetEnumerator                          IList lt T gt  currentChunk   new List lt T gt                 while  sourceEnumerator MoveNext                                  currentChunk Add sourceEnumerator Current                   if  currentChunk Count    chunkSize                                        yield return currentChunk                      currentChunk   new List lt T gt                                                  if  currentChunk Any                                  yield return currentChunk

User · Answer

For anyone interested in a packaged maintained solution  the MoreLINQ library provides the Batch extension method which matches your requested behavior   IEnumerable lt char gt  source    Example string   IEnumerable lt IEnumerable lt char gt  gt  chunksOfThreeChars   source Batch 3     The Batch implementation is similar to Cameron MacFarland s answer  with the addition of an overload for transforming the chunk batch before returning  and performs quite well

User · Answer

We can improve  JaredPar s solution to do true lazy evaluation  We use a GroupAdjacentBy method that yields groups of consecutive elements with the same key   sequence  Select  x  i    gt  new   Value   x  Index   i     GroupAdjacentBy x  gt x Index 3   Select g  gt g Select x  gt x Value     Because the groups are yielded one-by-one  this solution works efficiently with long or infinite sequences

User · Answer

To insert my two cents     By using the list type for the source to be chunked  I found another very compact solution   public static IEnumerable lt IEnumerable lt TSource gt  gt  Chunk lt TSource gt  this IEnumerable lt TSource gt  source  int chunkSize           copy the source into a list     var chunkList   source ToList            return chunks of  chunkSize  items     while  chunkList Count  gt  chunkSize                yield return chunkList GetRange 0  chunkSize           chunkList RemoveRange 0  chunkSize                 return the rest     yield return chunkList

User · Answer

It s an old solution but I had a different approach  I use Skip to move to desired offset and Take to extract desired number of elements   public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source                                                      int chunkSize        if  chunkSize  lt   0          throw new ArgumentOutOfRangeException    nameof chunkSize   should be  gt  0         var nbChunks    int Math Ceiling  double source Count   chunkSize        return Enumerable Range 0  nbChunks                        Select chunkNb   gt  source Skip chunkNb chunkSize                        Take chunkSize

User · Answer

I think the following suggestion would be the fastest  I am sacrificing the lazyness of the source Enumerable for the ability to use Array Copy and knowing ahead of the time the length of each of my sublists   public static IEnumerable lt T   gt  Chunk lt T gt  this IEnumerable lt T gt  items  int size        T   array   items as T      items ToArray        for  int i   0  i  lt  array Length  i  size                T   chunk   new T Math Min size  array Length - i            Array Copy array  i  chunk  0  chunk Length           yield return chunk

User · Answer

So performatic as the Sam Saffron s approach   public static IEnumerable lt IEnumerable lt T gt  gt  Batch lt T gt  this IEnumerable lt T gt  source  int size        if  source    null  throw new ArgumentNullException nameof source        if  size  lt   0  throw new ArgumentOutOfRangeException nameof size    Size must be greater than zero          return BatchImpl source  size  TakeWhile x   gt  x Any        static IEnumerable lt IEnumerable lt T gt  gt  BatchImpl lt T gt  this IEnumerable lt T gt  source  int size        var values   new List lt T gt         var group   1      var disposed   false      var e   source GetEnumerator         try               while   disposed                        yield return GetBatch e  values  group  size       gt    e Dispose    disposed   true                  group                        finally               if   disposed              e Dispose             static IEnumerable lt T gt  GetBatch lt T gt  IEnumerator lt T gt  e  List lt T gt  values  int group  int size  Action dispose        var min    group - 1    size   1      var max   group   size      var hasValue   false       while  values Count  lt  min  amp  amp  e MoveNext                  values Add e Current              for  var i   min  i  lt   max  i                  if  i  lt   values Count                        hasValue   true                    else if  hasValue   e MoveNext                          values Add e Current                     else                       dispose                       if  hasValue              yield return values i - 1           else             yield break

User · Answer

Using modular partitioning   public IEnumerable lt IEnumerable lt string gt  gt  Split IEnumerable lt string gt  input  int chunkSize        var chunks    int Math Ceiling  double input Count      double chunkSize       return Enumerable Range 0  chunks  Select id   gt  input Where s   gt  s GetHashCode     chunks    id

User · Answer

Try the following code   public static IList lt IList lt T gt  gt  Split lt T gt  IList lt T gt  source        return  source          Select  x  i    gt  new   Index   i  Value   x             GroupBy x   gt  x Index   3           Select x   gt  x Select v   gt  v Value  ToList             ToList        The idea is to first group the elements by indexes   Dividing by three has the effect of grouping them into groups of 3   Then convert each group to a list and the IEnumerable of List to a List of Lists

User · Answer

Try the following code   public static IList lt IList lt T gt  gt  Split lt T gt  IList lt T gt  source        return  source          Select  x  i    gt  new   Index   i  Value   x             GroupBy x   gt  x Index   3           Select x   gt  x Select v   gt  v Value  ToList             ToList        The idea is to first group the elements by indexes   Dividing by three has the effect of grouping them into groups of 3   Then convert each group to a list and the IEnumerable of List to a List of Lists

User · Answer

completely lazy  no counting or copying   public static class EnumerableExtensions      public static IEnumerable lt IEnumerable lt T gt  gt  Split lt T gt  this IEnumerable lt T gt  source  int len           if  len    0          throw new ArgumentNullException          var enumer   source GetEnumerator         while  enumer MoveNext                   yield return Take enumer Current  enumer  len                 private static IEnumerable lt T gt  Take lt T gt  T head  IEnumerator lt T gt  tail  int len           while  true                 yield return head          if  --len    0             break          if  tail MoveNext               head   tail Current          else            break

User · Answer

I just wrote this  and I think it s a little more elegant than the other proposed solutions       lt summary gt      Break a list of items into chunks of a specific size      lt  summary gt  public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source  int chunksize        while  source Any                  yield return source Take chunksize           source   source Skip chunksize

User · Answer

For anyone interested in a packaged maintained solution  the MoreLINQ library provides the Batch extension method which matches your requested behavior   IEnumerable lt char gt  source    Example string   IEnumerable lt IEnumerable lt char gt  gt  chunksOfThreeChars   source Batch 3     The Batch implementation is similar to Cameron MacFarland s answer  with the addition of an overload for transforming the chunk batch before returning  and performs quite well

User · Answer

The question was how to  quot Split List into Sublists with LINQ quot   but sometimes you may want those sub-lists to be references to the original list  not copies  This allows you to modify the original list from the sub-lists  In that case  this may work for you  public static IEnumerable lt Memory lt T gt  gt  RefChunkBy lt T gt  this T   array  int size        if  size  lt  1    array is null                throw new ArgumentException  quot chunkSize must be positive quot               var index   0      var counter   0       for  int i   0  i  lt  array Length  i                  if  counter    size                        yield return new Memory lt T gt  array  index  size               index   i              counter   0                    counter             if  i   1    array Length                        yield return new Memory lt T gt  array  index  array Length - index                      Usage  var src   new     1  2  3  4  5  6     var c3   RefChunkBy src  3             1  2  3    4  5  6    var c4   RefChunkBy src  4             1  2  3  4    5  6        as extension method var c3   src RefChunkBy 3             1  2  3    4  5  6    var c4   src RefChunkBy 4             1  2  3  4    5  6     var sum   c3 Select c   gt  c Span ToArray   Sum            6  15  var count   c3 Count                       2 var take2   c3 Select c   gt  c Span ToArray   Take 2          1  2    4  5    Feel free to make this code better

User · Answer

completely lazy  no counting or copying   public static class EnumerableExtensions      public static IEnumerable lt IEnumerable lt T gt  gt  Split lt T gt  this IEnumerable lt T gt  source  int len           if  len    0          throw new ArgumentNullException          var enumer   source GetEnumerator         while  enumer MoveNext                   yield return Take enumer Current  enumer  len                 private static IEnumerable lt T gt  Take lt T gt  T head  IEnumerator lt T gt  tail  int len           while  true                 yield return head          if  --len    0             break          if  tail MoveNext               head   tail Current          else            break

User · Answer

To insert my two cents     By using the list type for the source to be chunked  I found another very compact solution   public static IEnumerable lt IEnumerable lt TSource gt  gt  Chunk lt TSource gt  this IEnumerable lt TSource gt  source  int chunkSize           copy the source into a list     var chunkList   source ToList            return chunks of  chunkSize  items     while  chunkList Count  gt  chunkSize                yield return chunkList GetRange 0  chunkSize           chunkList RemoveRange 0  chunkSize                 return the rest     yield return chunkList

User · Answer

public static List lt List lt T gt  gt  GetSplitItemsList lt T gt  List lt T gt  originalItemsList  short number                var listGroup   new List lt List lt T gt  gt             int j   number          for  int i   0  i  lt  originalItemsList Count  i    number                        var cList   originalItemsList Take j  Skip i  ToList                j    number              listGroup Add cList                     return listGroup

User · Answer

What about this one   var input   new List lt string gt     a    g    e    w    p    s    q    f    x    y    i    m    c     var k   3  var res   Enumerable Range 0   input Count - 1    k   1                       Select i   gt  input GetRange i   k  Math Min k  input Count - i   k                         ToList      As far as I know  GetRange   is linear in terms of number of items taken  So this should perform well

User · Answer

The question was how to  quot Split List into Sublists with LINQ quot   but sometimes you may want those sub-lists to be references to the original list  not copies  This allows you to modify the original list from the sub-lists  In that case  this may work for you  public static IEnumerable lt Memory lt T gt  gt  RefChunkBy lt T gt  this T   array  int size        if  size  lt  1    array is null                throw new ArgumentException  quot chunkSize must be positive quot               var index   0      var counter   0       for  int i   0  i  lt  array Length  i                  if  counter    size                        yield return new Memory lt T gt  array  index  size               index   i              counter   0                    counter             if  i   1    array Length                        yield return new Memory lt T gt  array  index  array Length - index                      Usage  var src   new     1  2  3  4  5  6     var c3   RefChunkBy src  3             1  2  3    4  5  6    var c4   RefChunkBy src  4             1  2  3  4    5  6        as extension method var c3   src RefChunkBy 3             1  2  3    4  5  6    var c4   src RefChunkBy 4             1  2  3  4    5  6     var sum   c3 Select c   gt  c Span ToArray   Sum            6  15  var count   c3 Count                       2 var take2   c3 Select c   gt  c Span ToArray   Take 2          1  2    4  5    Feel free to make this code better

User · Answer

Can work with infinite generators   a Zip a Skip 1    x  y    gt  Enumerable Repeat x  1  Concat Enumerable Repeat y  1      Zip a Skip 2    xy  z    gt  xy Concat Enumerable Repeat z  1      Where  x  i    gt  i   3    0    Demo code  https   ideone com GKmL7M  using System  using System Collections Generic  using System Linq   public class Test     private static void DoIt IEnumerable lt int gt  a          Console WriteLine String Join      a         foreach  var x in a Zip a Skip 1    x  y    gt  Enumerable Repeat x  1  Concat Enumerable Repeat y  1    Zip a Skip 2    xy  z    gt  xy Concat Enumerable Repeat z  1    Where  x  i    gt  i   3    0         Console WriteLine String Join      x         Console WriteLine           public static void Main           DoIt new int    1        DoIt new int    1  2        DoIt new int    1  2  3        DoIt new int    1  2  3  4        DoIt new int    1  2  3  4  5        DoIt new int    1  2  3  4  5  6              1  1 2  1 2 3 1 2 3  1 2 3 4 1 2 3  1 2 3 4 5 1 2 3  1 2 3 4 5 6 1 2 3 4 5 6   But actually I would prefer to write corresponding method without linq

User · Answer

Here s a list splitting routine I wrote a couple months ago   public static List lt List lt T gt  gt  Chunk lt T gt       List lt T gt  theList      int chunkSize         List lt List lt T gt  gt  result   theList          Select  x  i    gt  new               data   x              indexgroup   i   chunkSize                     GroupBy x   gt  x indexgroup  x   gt  x data           Select g   gt  new List lt T gt  g            ToList         return result

User · Answer

This is an old question but this is what I ended up with  it enumerates the enumerable only once  but does create lists for each of the partitions  It doesn t suffer from unexpected behavior when ToArray   is called as some of the implementations do       public static IEnumerable lt IEnumerable lt T gt  gt  Partition lt T gt  IEnumerable lt T gt  source  int chunkSize                if  source    null                        throw new ArgumentNullException  source                       if  chunkSize  lt  1                        throw new ArgumentException  Invalid chunkSize      chunkSize                      using  IEnumerator lt T gt  sourceEnumerator   source GetEnumerator                          IList lt T gt  currentChunk   new List lt T gt                 while  sourceEnumerator MoveNext                                  currentChunk Add sourceEnumerator Current                   if  currentChunk Count    chunkSize                                        yield return currentChunk                      currentChunk   new List lt T gt                                                  if  currentChunk Any                                  yield return currentChunk

User · Answer

System Interactive provides Buffer   for this purpose  Some quick testing shows performance is similar to Sam s solution

User · Answer

If the source collection implements IList  lt  T  gt   random access by index  we could use the below approach  It only fetches the elements when they are really accessed  so this is particularly useful for lazily-evaluated collections  Similar to unbounded IEnumerable lt  T  gt   but for IList lt  T  gt       public static IEnumerable lt IEnumerable lt T gt  gt  Chunkify lt T gt  this IList lt T gt  src  int chunkSize                if  src    null  throw new ArgumentNullException nameof src            if  chunkSize  lt  1  throw new ArgumentOutOfRangeException nameof chunkSize     quot must be  gt  0  got  chunkSize  quot             for var ci   0  ci  lt   src Count chunkSize  ci                 yield return Window src  ci chunkSize  Math Min  ci 1  chunkSize  src Count -1                        private static IEnumerable lt T gt  Window lt T gt  IList lt T gt  src  int startIdx  int endIdx                Console WriteLine   quot window  startIdx  -  endIdx  quot            while startIdx  lt   endIdx               yield return src startIdx

User · Answer

public static List lt List lt T gt  gt  GetSplitItemsList lt T gt  List lt T gt  originalItemsList  short number                var listGroup   new List lt List lt T gt  gt             int j   number          for  int i   0  i  lt  originalItemsList Count  i    number                        var cList   originalItemsList Take j  Skip i  ToList                j    number              listGroup Add cList                     return listGroup

User · Answer

Here s a list splitting routine I wrote a couple months ago   public static List lt List lt T gt  gt  Chunk lt T gt       List lt T gt  theList      int chunkSize         List lt List lt T gt  gt  result   theList          Select  x  i    gt  new               data   x              indexgroup   i   chunkSize                     GroupBy x   gt  x indexgroup  x   gt  x data           Select g   gt  new List lt T gt  g            ToList         return result

User · Answer

Another way is using Rx Buffer operator    using System Linq    using System Reactive Linq    using System Reactive Threading Tasks   var observableBatches   anAnumerable ToObservable   Buffer size    var batches   aList ToObservable   Buffer size  ToList   ToTask   GetAwaiter   GetResult

User · Answer

We found David B s solution worked the best  But we adapted it to a more general solution   list GroupBy item   gt  item SomeProperty       Select group   gt  new List lt T gt  group        ToArray

User · Answer

I took the primary answer and made it to be an IOC container to determine where to split   For who is really looking to only split on 3 items  in reading this post while searching for an answer     This method allows one to split on any type of item as needed   public static List lt List lt T gt  gt  SplitOn lt T gt  List lt T gt  main  Func lt T  bool gt  splitOn        int groupIndex   0       return main Select  item   gt  new                                                                 Group    splitOn Invoke item      groupIndex   groupIndex                                   Value   item                                                   GroupBy  it2   gt  it2 Group                   Select x   gt  x Select v   gt  v Value  ToList                     ToList          So for the OP the code would be  var it   new List lt string gt                              a    g    e    w    p    s    q    f    x    y    i    m    c      int index   0   var result   SplitOn it   itm    gt   index     3     0

User · Answer

Old code  but this is what I ve been using       public static IEnumerable lt List lt T gt  gt  InSetsOf lt T gt  this IEnumerable lt T gt  source  int max                var toReturn   new List lt T gt  max           foreach  var item in source                        toReturn Add item               if  toReturn Count    max                                yield return toReturn                  toReturn   new List lt T gt  max                                   if  toReturn Any                          yield return toReturn

User · Answer

I find this little snippet does the job quite nicely   public static IEnumerable lt List lt T gt  gt  Chunked lt T gt  this List lt T gt  source  int chunkSize        var offset   0       while  offset  lt  source Count                yield return source GetRange offset  Math Min source Count - offset  chunkSize            offset    chunkSize

User · Answer

Check this out  I have a list of elements with a sequence counter and date  For each time the sequence restarts  I want to create a new list   Ex  list of messages    List lt dynamic gt  messages   new List lt dynamic gt                        new   FcntUp   101  CommTimestamp    2019-01-01 00 00 01                 new   FcntUp   102  CommTimestamp    2019-01-01 00 00 02                 new   FcntUp   103  CommTimestamp    2019-01-01 00 00 03                    restart of sequence             new   FcntUp   1  CommTimestamp    2019-01-01 00 00 04                 new   FcntUp   2  CommTimestamp    2019-01-01 00 00 05                 new   FcntUp   3  CommTimestamp    2019-01-01 00 00 06                    restart of sequence             new   FcntUp   1  CommTimestamp    2019-01-01 00 00 07                 new   FcntUp   2  CommTimestamp    2019-01-01 00 00 08                 new   FcntUp   3  CommTimestamp    2019-01-01 00 00 09                 I want to split the list into separate lists as the counter restarts  Here is the code   var arraylist   new List lt List lt dynamic gt  gt              List lt dynamic gt  messages   new List lt dynamic gt                        new   FcntUp   101  CommTimestamp    2019-01-01 00 00 01                 new   FcntUp   102  CommTimestamp    2019-01-01 00 00 02                 new   FcntUp   103  CommTimestamp    2019-01-01 00 00 03                    restart of sequence             new   FcntUp   1  CommTimestamp    2019-01-01 00 00 04                 new   FcntUp   2  CommTimestamp    2019-01-01 00 00 05                 new   FcntUp   3  CommTimestamp    2019-01-01 00 00 06                    restart of sequence             new   FcntUp   1  CommTimestamp    2019-01-01 00 00 07                 new   FcntUp   2  CommTimestamp    2019-01-01 00 00 08                 new   FcntUp   3  CommTimestamp    2019-01-01 00 00 09                          group by FcntUp and CommTimestamp         var query   messages GroupBy x   gt  new   x FcntUp  x CommTimestamp                declare the current item         dynamic currentItem   null             declare the list of ranges         List lt dynamic gt  range   null             loop through the sorted list         foreach  var item in query                          check if start of new range             if  currentItem    null    item Key FcntUp  lt  currentItem Key FcntUp                                  create a new list if the FcntUp starts on a new range                 range   new List lt dynamic gt                        add the list to the parent list                 arraylist Add range                                add the item to the sublist             range Add item                  set the current item             currentItem   item

User · Answer

If the list is of type system collections generic you can use the  CopyTo  method available to copy elements of your array to other sub arrays  You specify the start element and number of elements to copy   You could also make 3 clones of your original list and use the  RemoveRange  on each list to shrink the list to the size you want   Or just create a helper method to do it for you

User · Answer

In general the approach suggested by CaseyB works fine  in fact if you are passing in a List lt T gt  it is hard to fault it  perhaps I would change it to   public static IEnumerable lt IEnumerable lt T gt  gt  ChunkTrivialBetter lt T gt  this IEnumerable lt T gt  source  int chunksize       var pos   0      while  source Skip pos  Any               yield return source Skip pos  Take chunksize         pos    chunksize           Which will avoid massive call chains  Nonetheless  this approach has a general flaw  It materializes two enumerations per chunk  to highlight the issue try running    foreach  var item in Enumerable Range 1  int MaxValue  Chunk 8  Skip 100000  First         Console WriteLine item        wait forever    To overcome this we can try Cameron s approach  which passes the above test in flying colors as it only walks the enumeration once    Trouble is that it has a different flaw  it materializes every item in each chunk  the trouble with that approach is that you run high on memory    To illustrate that try running   foreach  var item in Enumerable Range 1  int MaxValue                  Select x   gt  x   new string  x   100000                   Clump 10000  Skip 100  First         Console Write            OutOfMemoryException   Finally  any implementation should be able to handle out of order iteration of chunks  for example   Enumerable Range 1 3  Chunk 2  Reverse   ToArray      should return  3   1 2    Many highly optimal solutions like my first revision of this answer failed there  The same issue can be seen in casperOne s optimized answer   To address all these issues you can use the following   namespace ChunkedEnumerator       public static class Extensions                class ChunkedEnumerable lt T gt    IEnumerable lt T gt                        class ChildEnumerator   IEnumerator lt T gt                                ChunkedEnumerable lt T gt  parent                  int position                  bool done   false                  T current                    public ChildEnumerator ChunkedEnumerable lt T gt  parent                                        this parent   parent                      position   -1                      parent wrapper AddRef                                       public T Current                                       get                                               if  position    -1    done                                                        throw new InvalidOperationException                                                      return current                                                            public void Dispose                                         if   done                                                done   true                          parent wrapper RemoveRef                                                             object System Collections IEnumerator Current                                       get   return Current                                       public bool MoveNext                                         position                         if  position   1  gt  parent chunkSize                                                done   true                                             if   done                                                done    parent wrapper Get position   parent start  out current                                              return  done                                      public void Reset                                            per http   msdn microsoft com en-us library system collections ienumerator reset aspx                     throw new NotSupportedException                                                 EnumeratorWrapper lt T gt  wrapper              int chunkSize              int start               public ChunkedEnumerable EnumeratorWrapper lt T gt  wrapper  int chunkSize  int start                                this wrapper   wrapper                  this chunkSize   chunkSize                  this start   start                             public IEnumerator lt T gt  GetEnumerator                                 return new ChildEnumerator this                              System Collections IEnumerator System Collections IEnumerable GetEnumerator                                 return GetEnumerator                                      class EnumeratorWrapper lt T gt                        public EnumeratorWrapper  IEnumerable lt T gt  source                                SourceEumerable   source                            IEnumerable lt T gt  SourceEumerable  get  set                Enumeration currentEnumeration               class Enumeration                               public IEnumerator lt T gt  Source   get  set                    public int Position   get  set                    public bool AtEnd   get  set                               public bool Get int pos  out T item                                  if  currentEnumeration    null  amp  amp  currentEnumeration Position  gt  pos                                        currentEnumeration Source Dispose                        currentEnumeration   null                                     if  currentEnumeration    null                                        currentEnumeration   new Enumeration   Position   -1  Source   SourceEumerable GetEnumerator    AtEnd   false                                       item   default T                   if  currentEnumeration AtEnd                                        return false                                     while currentEnumeration Position  lt  pos                                         currentEnumeration AtEnd    currentEnumeration Source MoveNext                        currentEnumeration Position                         if  currentEnumeration AtEnd                                                 return false                                                            item   currentEnumeration Source Current                   return true                             int refs   0                  needed for dispose semantics              public void AddRef                                 refs                               public void RemoveRef                                 refs--                  if  refs    0  amp  amp  currentEnumeration    null                                        var copy   currentEnumeration                      currentEnumeration   null                      copy Source Dispose                                                       public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source  int chunksize                        if  chunksize  lt  1  throw new InvalidOperationException                 var wrapper    new EnumeratorWrapper lt T gt  source                int currentPos   0              T ignore              try                               wrapper AddRef                    while  wrapper Get currentPos  out ignore                                         yield return new ChunkedEnumerable lt T gt  wrapper  chunksize  currentPos                       currentPos    chunksize                                              finally                               wrapper RemoveRef                                       class Program               static void Main string   args                        int i   10              foreach  var group in Enumerable Range 1  int MaxValue  Skip 10000000  Chunk 3                                 foreach  var n in group                                        Console Write n                       Console Write                                         Console WriteLine                    if  i--    0  break                              var stuffs   Enumerable Range 1  10  Chunk 2  ToArray                 foreach  var idx in new     3 2 1                                 Console Write  idx     idx                         foreach  var n in stuffs idx                                         Console Write n                       Console Write                                         Console WriteLine                                   10000001 10000002 10000003 10000004 10000005 10000006 10000007 10000008 10000009 10000010 10000011 10000012 10000013 10000014 10000015 10000016 10000017 10000018 10000019 10000020 10000021 10000022 10000023 10000024 10000025 10000026 10000027 10000028 10000029 10000030 10000031 10000032 10000033 idx 3 7 8 idx 2 5 6 idx 1 3 4                              Console ReadKey                           There is also a round of optimisations you could introduce for out-of-order iteration of chunks  which is out of scope here    As to which method you should choose  It totally depends on the problem you are trying to solve  If you are not concerned with the first flaw the simple answer is incredibly appealing   Note as with most methods  this is not safe for multi threading  stuff can get weird if you wish to make it thread safe you would need to amend EnumeratorWrapper

User · Answer

This following solution is the most compact I could come up with that is O n    public static IEnumerable lt T   gt  Chunk lt T gt  IEnumerable lt T gt  source  int chunksize        var list   source as IList lt T gt     source ToList        for  int start   0  start  lt  list Count  start    chunksize                T   chunk   new T Math Min chunksize  list Count - start            for  int i   0  i  lt  chunk Length  i                chunk i    list start   i            yield return chunk

User · Answer

Here s a list splitting routine I wrote a couple months ago   public static List lt List lt T gt  gt  Chunk lt T gt       List lt T gt  theList      int chunkSize         List lt List lt T gt  gt  result   theList          Select  x  i    gt  new               data   x              indexgroup   i   chunkSize                     GroupBy x   gt  x indexgroup  x   gt  x data           Select g   gt  new List lt T gt  g            ToList         return result

User · Answer

We can improve  JaredPar s solution to do true lazy evaluation  We use a GroupAdjacentBy method that yields groups of consecutive elements with the same key   sequence  Select  x  i    gt  new   Value   x  Index   i     GroupAdjacentBy x  gt x Index 3   Select g  gt g Select x  gt x Value     Because the groups are yielded one-by-one  this solution works efficiently with long or infinite sequences

User · Answer

You could use a number of queries that use Take and Skip  but that would add too many iterations on the original list  I believe  Rather  I think you should create an iterator of your own  like so  public static IEnumerable lt IEnumerable lt T gt  gt  GetEnumerableOfEnumerables lt T gt     IEnumerable lt T gt  enumerable  int groupSize          The list to return     List lt T gt  list   new List lt T gt  groupSize          Cycle through all of the items     foreach  T item in enumerable               Add the item       list Add item            If the list has the number of elements  return that       if  list Count    groupSize                   Return the list         yield return list             Set the list to a new list         list   new List lt T gt  groupSize                      Return the remainder if there is any     if  list Count    0               Return the list       yield return list          You can then call this and it is LINQ enabled so you can perform other operations on the resulting sequences   In light of Sam s answer  I felt there was an easier way to do this without   Iterating through the list again  which I didn t do originally  Materializing the items in groups before releasing the chunk  for large chunks of items  there would be memory issues  All of the code that Sam posted  That said  here s another pass  which I ve codified in an extension method to IEnumerable lt T gt  called Chunk  public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source       int chunkSize           Validate parameters      if  source    null  throw new ArgumentNullException nameof source        if  chunkSize  lt   0  throw new ArgumentOutOfRangeException nameof chunkSize            quot The chunkSize parameter must be a positive value  quot            Call the internal implementation      return source ChunkInternal chunkSize      Nothing surprising up there  just basic error checking  Moving on to ChunkInternal  private static IEnumerable lt IEnumerable lt T gt  gt  ChunkInternal lt T gt       this IEnumerable lt T gt  source  int chunkSize           Validate parameters      Debug Assert source    null       Debug Assert chunkSize  gt  0           Get the enumerator   Dispose of when done      using  IEnumerator lt T gt  enumerator   source GetEnumerator        do                  Move to the next element   If there s nothing left            then get out          if   enumerator MoveNext    yield break              Return the chunked sequence          yield return ChunkSequence enumerator  chunkSize         while  true      Basically  it gets the IEnumerator lt T gt  and manually iterates through each item   It checks to see if there any items currently to be enumerated   After each chunk is enumerated through  if there aren t any items left  it breaks out  Once it detects there are items in the sequence  it delegates the responsibility for the inner IEnumerable lt T gt  implementation to ChunkSequence  private static IEnumerable lt T gt  ChunkSequence lt T gt  IEnumerator lt T gt  enumerator       int chunkSize           Validate parameters      Debug Assert enumerator    null       Debug Assert chunkSize  gt  0           The count      int count   0          There is at least one item   Yield and then continue      do                  Yield the item          yield return enumerator Current        while    count  lt  chunkSize  amp  amp  enumerator MoveNext        Since MoveNext was already called on the IEnumerator lt T gt  passed to ChunkSequence  it yields the item returned by Current and then increments the count  making sure never to return more than chunkSize items and moving to the next item in the sequence after every iteration  but short-circuited if the number of items yielded exceeds the chunk size   If there are no items left  then the InternalChunk method will make another pass in the outer loop  but when MoveNext is called a second time  it will still return false  as per the documentation  emphasis mine    If MoveNext passes the end of the collection  the enumerator is positioned after the last element in the collection and MoveNext returns false  When the enumerator is at this position  subsequent calls to MoveNext also return false until Reset is called   At this point  the loop will break  and the sequence of sequences will terminate  This is a simple test  static void Main         string s    quot agewpsqfxyimc quot        int count   0          Group by three      foreach  IEnumerable lt char gt  g in s Chunk 3                    Print out the group          Console Write  quot Group   0  -  quot     count               Print the items          foreach  char c in g                           Print the item              Console Write c    quot    quot                          Finish the line          Console WriteLine             Output  Group  1 - a  g  e  Group  2 - w  p  s  Group  3 - q  f  x  Group  4 - y  i  m  Group  5 - c   An important note  this will not work if you don t drain the entire child sequence or break at any point in the parent sequence   This is an important caveat  but if your use case is that you will consume every element of the sequence of sequences  then this will work for you  Additionally  it will do strange things if you play with the order  just as Sam s did at one point

User · Answer

You could use a number of queries that use Take and Skip  but that would add too many iterations on the original list  I believe  Rather  I think you should create an iterator of your own  like so  public static IEnumerable lt IEnumerable lt T gt  gt  GetEnumerableOfEnumerables lt T gt     IEnumerable lt T gt  enumerable  int groupSize          The list to return     List lt T gt  list   new List lt T gt  groupSize          Cycle through all of the items     foreach  T item in enumerable               Add the item       list Add item            If the list has the number of elements  return that       if  list Count    groupSize                   Return the list         yield return list             Set the list to a new list         list   new List lt T gt  groupSize                      Return the remainder if there is any     if  list Count    0               Return the list       yield return list          You can then call this and it is LINQ enabled so you can perform other operations on the resulting sequences   In light of Sam s answer  I felt there was an easier way to do this without   Iterating through the list again  which I didn t do originally  Materializing the items in groups before releasing the chunk  for large chunks of items  there would be memory issues  All of the code that Sam posted  That said  here s another pass  which I ve codified in an extension method to IEnumerable lt T gt  called Chunk  public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source       int chunkSize           Validate parameters      if  source    null  throw new ArgumentNullException nameof source        if  chunkSize  lt   0  throw new ArgumentOutOfRangeException nameof chunkSize            quot The chunkSize parameter must be a positive value  quot            Call the internal implementation      return source ChunkInternal chunkSize      Nothing surprising up there  just basic error checking  Moving on to ChunkInternal  private static IEnumerable lt IEnumerable lt T gt  gt  ChunkInternal lt T gt       this IEnumerable lt T gt  source  int chunkSize           Validate parameters      Debug Assert source    null       Debug Assert chunkSize  gt  0           Get the enumerator   Dispose of when done      using  IEnumerator lt T gt  enumerator   source GetEnumerator        do                  Move to the next element   If there s nothing left            then get out          if   enumerator MoveNext    yield break              Return the chunked sequence          yield return ChunkSequence enumerator  chunkSize         while  true      Basically  it gets the IEnumerator lt T gt  and manually iterates through each item   It checks to see if there any items currently to be enumerated   After each chunk is enumerated through  if there aren t any items left  it breaks out  Once it detects there are items in the sequence  it delegates the responsibility for the inner IEnumerable lt T gt  implementation to ChunkSequence  private static IEnumerable lt T gt  ChunkSequence lt T gt  IEnumerator lt T gt  enumerator       int chunkSize           Validate parameters      Debug Assert enumerator    null       Debug Assert chunkSize  gt  0           The count      int count   0          There is at least one item   Yield and then continue      do                  Yield the item          yield return enumerator Current        while    count  lt  chunkSize  amp  amp  enumerator MoveNext        Since MoveNext was already called on the IEnumerator lt T gt  passed to ChunkSequence  it yields the item returned by Current and then increments the count  making sure never to return more than chunkSize items and moving to the next item in the sequence after every iteration  but short-circuited if the number of items yielded exceeds the chunk size   If there are no items left  then the InternalChunk method will make another pass in the outer loop  but when MoveNext is called a second time  it will still return false  as per the documentation  emphasis mine    If MoveNext passes the end of the collection  the enumerator is positioned after the last element in the collection and MoveNext returns false  When the enumerator is at this position  subsequent calls to MoveNext also return false until Reset is called   At this point  the loop will break  and the sequence of sequences will terminate  This is a simple test  static void Main         string s    quot agewpsqfxyimc quot        int count   0          Group by three      foreach  IEnumerable lt char gt  g in s Chunk 3                    Print out the group          Console Write  quot Group   0  -  quot     count               Print the items          foreach  char c in g                           Print the item              Console Write c    quot    quot                          Finish the line          Console WriteLine             Output  Group  1 - a  g  e  Group  2 - w  p  s  Group  3 - q  f  x  Group  4 - y  i  m  Group  5 - c   An important note  this will not work if you don t drain the entire child sequence or break at any point in the parent sequence   This is an important caveat  but if your use case is that you will consume every element of the sequence of sequences  then this will work for you  Additionally  it will do strange things if you play with the order  just as Sam s did at one point

User · Answer

Try the following code   public static IList lt IList lt T gt  gt  Split lt T gt  IList lt T gt  source        return  source          Select  x  i    gt  new   Index   i  Value   x             GroupBy x   gt  x Index   3           Select x   gt  x Select v   gt  v Value  ToList             ToList        The idea is to first group the elements by indexes   Dividing by three has the effect of grouping them into groups of 3   Then convert each group to a list and the IEnumerable of List to a List of Lists

User · Answer

If the list is of type system collections generic you can use the  CopyTo  method available to copy elements of your array to other sub arrays  You specify the start element and number of elements to copy   You could also make 3 clones of your original list and use the  RemoveRange  on each list to shrink the list to the size you want   Or just create a helper method to do it for you

User · Answer

I find this little snippet does the job quite nicely   public static IEnumerable lt List lt T gt  gt  Chunked lt T gt  this List lt T gt  source  int chunkSize        var offset   0       while  offset  lt  source Count                yield return source GetRange offset  Math Min source Count - offset  chunkSize            offset    chunkSize

User · Answer

Old code  but this is what I ve been using       public static IEnumerable lt List lt T gt  gt  InSetsOf lt T gt  this IEnumerable lt T gt  source  int max                var toReturn   new List lt T gt  max           foreach  var item in source                        toReturn Add item               if  toReturn Count    max                                yield return toReturn                  toReturn   new List lt T gt  max                                   if  toReturn Any                          yield return toReturn

User · Answer

Check this out  I have a list of elements with a sequence counter and date  For each time the sequence restarts  I want to create a new list   Ex  list of messages    List lt dynamic gt  messages   new List lt dynamic gt                        new   FcntUp   101  CommTimestamp    2019-01-01 00 00 01                 new   FcntUp   102  CommTimestamp    2019-01-01 00 00 02                 new   FcntUp   103  CommTimestamp    2019-01-01 00 00 03                    restart of sequence             new   FcntUp   1  CommTimestamp    2019-01-01 00 00 04                 new   FcntUp   2  CommTimestamp    2019-01-01 00 00 05                 new   FcntUp   3  CommTimestamp    2019-01-01 00 00 06                    restart of sequence             new   FcntUp   1  CommTimestamp    2019-01-01 00 00 07                 new   FcntUp   2  CommTimestamp    2019-01-01 00 00 08                 new   FcntUp   3  CommTimestamp    2019-01-01 00 00 09                 I want to split the list into separate lists as the counter restarts  Here is the code   var arraylist   new List lt List lt dynamic gt  gt              List lt dynamic gt  messages   new List lt dynamic gt                        new   FcntUp   101  CommTimestamp    2019-01-01 00 00 01                 new   FcntUp   102  CommTimestamp    2019-01-01 00 00 02                 new   FcntUp   103  CommTimestamp    2019-01-01 00 00 03                    restart of sequence             new   FcntUp   1  CommTimestamp    2019-01-01 00 00 04                 new   FcntUp   2  CommTimestamp    2019-01-01 00 00 05                 new   FcntUp   3  CommTimestamp    2019-01-01 00 00 06                    restart of sequence             new   FcntUp   1  CommTimestamp    2019-01-01 00 00 07                 new   FcntUp   2  CommTimestamp    2019-01-01 00 00 08                 new   FcntUp   3  CommTimestamp    2019-01-01 00 00 09                          group by FcntUp and CommTimestamp         var query   messages GroupBy x   gt  new   x FcntUp  x CommTimestamp                declare the current item         dynamic currentItem   null             declare the list of ranges         List lt dynamic gt  range   null             loop through the sorted list         foreach  var item in query                          check if start of new range             if  currentItem    null    item Key FcntUp  lt  currentItem Key FcntUp                                  create a new list if the FcntUp starts on a new range                 range   new List lt dynamic gt                        add the list to the parent list                 arraylist Add range                                add the item to the sublist             range Add item                  set the current item             currentItem   item

User · Answer

Just putting in my two cents   If you wanted to  bucket  the list  visualize left to right   you could do the following    public static List lt List lt T gt  gt  Buckets lt T gt  this List lt T gt  source  int numberOfBuckets                List lt List lt T gt  gt  result   new List lt List lt T gt  gt             for  int i   0  i  lt  numberOfBuckets  i                          result Add new List lt T gt                         int count   0          while  count  lt  source Count                          var mod   count   numberOfBuckets              result mod  Add source count                count                      return result

User · Answer

There is no way to combine all desirable features like full lazyness, no copying, full generality and safety in one solution. The most fundamental reason is that it cannot be guaranteed that the input is not mutated before the chunks are accessed. Assume that we have a function of the following signature:

public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunkSize)
{
    // Some implementation
}

Then the following way to use it is problematic:

var myList = new List<int>()
{
    1,2,3,4
};
var myChunks = myList.Chunk(2);
myList.RemoveAt(0);
var firstChunk = myChunks.First();    
Console.WriteLine("First chunk:" + String.Join(',', firstChunk));
myList.RemoveAt(0);
var secondChunk = myChunks.Skip(1).First();
Console.WriteLine("Second chunk:" + String.Join(',', secondChunk));
// What outputs do we see for first and second chunk? Probably not what you would expect...

Depending on the specific implementation the code will either fail with a runtime error or produce unintuitive results.

So, at least one of the properties need to be weakened. If you want a bullet-proof lazy solution you need to restrict your input type to an immutable type and even then it is not straightforward to cover up all use cases. If you have control of the usage, you could, however, still opt for the most general solution, as long as you make sure that it is used in a way that works. Otherwise, you might drop the lazyness and accept some amount of copying.

In the end, it all depends on your use case and requirements which solution is the best choice for you.

User · Answer

We found David B s solution worked the best  But we adapted it to a more general solution   list GroupBy item   gt  item SomeProperty       Select group   gt  new List lt T gt  group        ToArray

User · Answer

Ok  here s my take on it    completely lazy  works on infinite enumerables no intermediate copying buffering O n  execution time  works also when inner sequences are only partially consumed        public static IEnumerable lt IEnumerable lt T gt  gt  Chunks lt T gt  this IEnumerable lt T gt  enumerable                                                      int chunkSize        if  chunkSize  lt  1  throw new ArgumentException  chunkSize must be positive         using  var e   enumerable GetEnumerator        while  e MoveNext                  var remaining   chunkSize        elements remaining in the current chunk         var innerMoveNext   new Func lt bool gt       gt  --remaining  gt  0  amp  amp  e MoveNext              yield return e GetChunk innerMoveNext           while  innerMoveNext        discard elements skipped by inner iterator              private static IEnumerable lt T gt  GetChunk lt T gt  this IEnumerator lt T gt  e                                            Func lt bool gt  innerMoveNext        do yield return e Current      while  innerMoveNext            Example Usage  var src   new     1  2  3  4  5  6     var c3   src Chunks 3             1  2  3    4  5  6     var c4   src Chunks 4             1  2  3  4    5  6      var sum     c3 Select c   gt  c Sum            6  15  var count   c3 Count                       2 var take2   c3 Select c   gt  c Take 2          1  2    4  5     Explanations      The code works by nesting two yield based iterators   The outer iterator must keep track of how many elements have been effectively consumed by the inner  chunk  iterator  This is done by closing over remaining with innerMoveNext    Unconsumed elements of a chunk are discarded before the next chunk is yielded by the outer iterator  This is necessary because otherwise you get inconsistent results  when the inner enumerables are not  completely  consumed  e g  c3 Count   would return 6       Note  The answer has been updated to address the shortcomings pointed out by  aolszowka

User · Answer

Just putting in my two cents   If you wanted to  bucket  the list  visualize left to right   you could do the following    public static List lt List lt T gt  gt  Buckets lt T gt  this List lt T gt  source  int numberOfBuckets                List lt List lt T gt  gt  result   new List lt List lt T gt  gt             for  int i   0  i  lt  numberOfBuckets  i                          result Add new List lt T gt                         int count   0          while  count  lt  source Count                          var mod   count   numberOfBuckets              result mod  Add source count                count                      return result

User · Answer

This following solution is the most compact I could come up with that is O n    public static IEnumerable lt T   gt  Chunk lt T gt  IEnumerable lt T gt  source  int chunksize        var list   source as IList lt T gt     source ToList        for  int start   0  start  lt  list Count  start    chunksize                T   chunk   new T Math Min chunksize  list Count - start            for  int i   0  i  lt  chunk Length  i                chunk i    list start   i            yield return chunk

User · Answer

I just wrote this  and I think it s a little more elegant than the other proposed solutions       lt summary gt      Break a list of items into chunks of a specific size      lt  summary gt  public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source  int chunksize        while  source Any                  yield return source Take chunksize           source   source Skip chunksize

User · Answer

If the list is of type system collections generic you can use the  CopyTo  method available to copy elements of your array to other sub arrays  You specify the start element and number of elements to copy   You could also make 3 clones of your original list and use the  RemoveRange  on each list to shrink the list to the size you want   Or just create a helper method to do it for you

User · Answer

Ok  here s my take on it    completely lazy  works on infinite enumerables no intermediate copying buffering O n  execution time  works also when inner sequences are only partially consumed        public static IEnumerable lt IEnumerable lt T gt  gt  Chunks lt T gt  this IEnumerable lt T gt  enumerable                                                      int chunkSize        if  chunkSize  lt  1  throw new ArgumentException  chunkSize must be positive         using  var e   enumerable GetEnumerator        while  e MoveNext                  var remaining   chunkSize        elements remaining in the current chunk         var innerMoveNext   new Func lt bool gt       gt  --remaining  gt  0  amp  amp  e MoveNext              yield return e GetChunk innerMoveNext           while  innerMoveNext        discard elements skipped by inner iterator              private static IEnumerable lt T gt  GetChunk lt T gt  this IEnumerator lt T gt  e                                            Func lt bool gt  innerMoveNext        do yield return e Current      while  innerMoveNext            Example Usage  var src   new     1  2  3  4  5  6     var c3   src Chunks 3             1  2  3    4  5  6     var c4   src Chunks 4             1  2  3  4    5  6      var sum     c3 Select c   gt  c Sum            6  15  var count   c3 Count                       2 var take2   c3 Select c   gt  c Take 2          1  2    4  5     Explanations      The code works by nesting two yield based iterators   The outer iterator must keep track of how many elements have been effectively consumed by the inner  chunk  iterator  This is done by closing over remaining with innerMoveNext    Unconsumed elements of a chunk are discarded before the next chunk is yielded by the outer iterator  This is necessary because otherwise you get inconsistent results  when the inner enumerables are not  completely  consumed  e g  c3 Count   would return 6       Note  The answer has been updated to address the shortcomings pointed out by  aolszowka

User · Answer

If the list is of type system collections generic you can use the  CopyTo  method available to copy elements of your array to other sub arrays  You specify the start element and number of elements to copy   You could also make 3 clones of your original list and use the  RemoveRange  on each list to shrink the list to the size you want   Or just create a helper method to do it for you

User · Answer

Can work with infinite generators   a Zip a Skip 1    x  y    gt  Enumerable Repeat x  1  Concat Enumerable Repeat y  1      Zip a Skip 2    xy  z    gt  xy Concat Enumerable Repeat z  1      Where  x  i    gt  i   3    0    Demo code  https   ideone com GKmL7M  using System  using System Collections Generic  using System Linq   public class Test     private static void DoIt IEnumerable lt int gt  a          Console WriteLine String Join      a         foreach  var x in a Zip a Skip 1    x  y    gt  Enumerable Repeat x  1  Concat Enumerable Repeat y  1    Zip a Skip 2    xy  z    gt  xy Concat Enumerable Repeat z  1    Where  x  i    gt  i   3    0         Console WriteLine String Join      x         Console WriteLine           public static void Main           DoIt new int    1        DoIt new int    1  2        DoIt new int    1  2  3        DoIt new int    1  2  3  4        DoIt new int    1  2  3  4  5        DoIt new int    1  2  3  4  5  6              1  1 2  1 2 3 1 2 3  1 2 3 4 1 2 3  1 2 3 4 5 1 2 3  1 2 3 4 5 6 1 2 3 4 5 6   But actually I would prefer to write corresponding method without linq

User · Answer

Try the following code   public static IList lt IList lt T gt  gt  Split lt T gt  IList lt T gt  source        return  source          Select  x  i    gt  new   Index   i  Value   x             GroupBy x   gt  x Index   3           Select x   gt  x Select v   gt  v Value  ToList             ToList        The idea is to first group the elements by indexes   Dividing by three has the effect of grouping them into groups of 3   Then convert each group to a list and the IEnumerable of List to a List of Lists

User · Answer

Here s a list splitting routine I wrote a couple months ago   public static List lt List lt T gt  gt  Chunk lt T gt       List lt T gt  theList      int chunkSize         List lt List lt T gt  gt  result   theList          Select  x  i    gt  new               data   x              indexgroup   i   chunkSize                     GroupBy x   gt  x indexgroup  x   gt  x data           Select g   gt  new List lt T gt  g            ToList         return result

[c#] Split List into Sublists with LINQ

Examples related to c#

Examples related to linq

Examples related to data-structures