Split a List into smaller lists of N size

前端 未结 17 1645
后悔当初
后悔当初 2020-11-22 16:55

I am attempting to split a list into a series of smaller lists.

My Problem: My function to split lists doesn\'t split them into lists of the correct

相关标签:
17条回答
  • 2020-11-22 17:56

    How about this one? The idea was to use only one loop. And, who knows, maybe you're using only IList implementations thorough your code and you don't want to cast to List.

    private IEnumerable<IList<T>> SplitList<T>(IList<T> list, int totalChunks)
    {
        IList<T> auxList = new List<T>();
        int totalItems = list.Count();
    
        if (totalChunks <= 0)
        {
            yield return auxList;
        }
        else 
        {
            for (int i = 0; i < totalItems; i++)
            {               
                auxList.Add(list[i]);           
    
                if ((i + 1) % totalChunks == 0)
                {
                    yield return auxList;
                    auxList = new List<T>();                
                }
    
                else if (i == totalItems - 1)
                {
                    yield return auxList;
                }
            }
        }   
    }
    
    0 讨论(0)
  • 2020-11-22 17:56

    Based on Dimitry Pavlov answere I would remove .ToList(). And also avoid the anonymous class. Instead I like to use a struct which does not require a heap memory allocation. (A ValueTuple would also do job.)

    public static IEnumerable<IEnumerable<TSource>> ChunkBy<TSource>(this IEnumerable<TSource> source, int chunkSize)
    {
        if (source is null)
        {
            throw new ArgumentNullException(nameof(source));
        }
        if (chunkSize <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(chunkSize), chunkSize, "The argument must be greater than zero.");
        }
    
        return source
            .Select((x, i) => new ChunkedValue<TSource>(x, i / chunkSize))
            .GroupBy(cv => cv.ChunkIndex)
            .Select(g => g.Select(cv => cv.Value));
    } 
    
    [StructLayout(LayoutKind.Auto)]
    [DebuggerDisplay("{" + nameof(ChunkedValue<T>.ChunkIndex) + "}: {" + nameof(ChunkedValue<T>.Value) + "}")]
    private struct ChunkedValue<T>
    {
        public ChunkedValue(T value, int chunkIndex)
        {
            this.ChunkIndex = chunkIndex;
            this.Value = value;
        }
    
        public int ChunkIndex { get; }
    
        public T Value { get; }
    }
    

    This can be used like the following which only iterates over the collection once and also does not allocate any significant memory.

    int chunkSize = 30;
    foreach (var chunk in collection.ChunkBy(chunkSize))
    {
        foreach (var item in chunk)
        {
            // your code for item here.
        }
    }
    

    If a concrete list is actually needed then I would do it like this:

    int chunkSize = 30;
    var chunkList = new List<List<T>>();
    foreach (var chunk in collection.ChunkBy(chunkSize))
    {
        // create a list with the correct capacity to be able to contain one chunk
        // to avoid the resizing (additional memory allocation and memory copy) within the List<T>.
        var list = new List<T>(chunkSize);
        list.AddRange(chunk);
        chunkList.Add(list);
    }
    
    0 讨论(0)
  • 2020-11-22 17:58
    public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> items, int maxItems)
    {
        return items.Select((item, index) => new { item, index })
                    .GroupBy(x => x.index / maxItems)
                    .Select(g => g.Select(x => x.item));
    }
    
    0 讨论(0)
  • 2020-11-22 17:58
    public static List<List<T>> ChunkBy<T>(this List<T> source, int chunkSize)
        {           
            var result = new List<List<T>>();
            for (int i = 0; i < source.Count; i += chunkSize)
            {
                var rows = new List<T>();
                for (int j = i; j < i + chunkSize; j++)
                {
                    if (j >= source.Count) break;
                    rows.Add(source[j]);
                }
                result.Add(rows);
            }
            return result;
        }
    
    0 讨论(0)
  • 2020-11-22 17:58

    I had encountered this same need, and I used a combination of Linq's Skip() and Take() methods. I multiply the number I take by the number of iterations this far, and that gives me the number of items to skip, then I take the next group.

            var categories = Properties.Settings.Default.MovementStatsCategories;
            var items = summariesWithinYear
                .Select(s =>  s.sku).Distinct().ToList();
    
            //need to run by chunks of 10,000
            var count = items.Count;
            var counter = 0;
            var numToTake = 10000;
    
            while (count > 0)
            {
                var itemsChunk = items.Skip(numToTake * counter).Take(numToTake).ToList();
                counter += 1;
    
                MovementHistoryUtilities.RecordMovementHistoryStatsBulk(itemsChunk, categories, nLogger);
    
                count -= numToTake;
            }
    
    0 讨论(0)
提交回复
热议问题