将列表拆分为 N 大小的较小列表的原理是通过迭代原列表，取出一定数量的元素，创建新的较小列表，然后将这些较小列表组合在一起。

方法

1. 使用循环手动拆分

   • 通过循环遍历原列表，手动截取指定数量的元素。

2. 使用LINQ的Skip和Take

   • 使用LINQ的Skip和Take方法，以指定步长拆分原列表。

3. 使用自定义方法

   • 实现一个自定义方法，通过索引来拆分原列表。

步骤

1. 使用循环手动拆分

   • 通过循环遍历原列表，使用GetRange方法手动截取指定数量的元素。

2. 使用LINQ的Skip和Take

   • 使用LINQ的Skip和Take方法，指定步长和拆分数量。

3. 使用自定义方法

   • 实现一个自定义方法，通过索引来拆分原列表。

实例源代码

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> originalList = Enumerable.Range(1, 20).ToList();

        // 方法 1: 使用循环手动拆分
        List<List<int>> splittedList1 = SplitListManually(originalList, 5);

        // 方法 2: 使用LINQ的 Skip 和 Take
        List<List<int>> splittedList2 = SplitListWithLinq(originalList, 5);

        // 方法 3: 使用自定义方法
        List<List<int>> splittedList3 = SplitListCustom(originalList, 5);

        // 打印结果
        PrintSplittedLists("手动拆分", splittedList1);
        PrintSplittedLists("LINQ拆分", splittedList2);
        PrintSplittedLists("自定义拆分", splittedList3);
    }

    // 方法 1: 使用循环手动拆分
    static List<List<int>> SplitListManually(List<int> originalList, int chunkSize)
    {
        List<List<int>> result = new List<List<int>>();

        for (int i = 0; i < originalList.Count; i += chunkSize)
        {
            List<int> chunk = originalList.GetRange(i, Math.Min(chunkSize, originalList.Count - i));
            result.Add(chunk);
        }

        return result;
    }

    // 方法 2: 使用LINQ的 Skip 和 Take
    static List<List<int>> SplitListWithLinq(List<int> originalList, int chunkSize)
    {
        int numberOfChunks = (int)Math.Ceiling((double)originalList.Count / chunkSize);

        return Enumerable.Range(0, numberOfChunks)
            .Select(i => originalList.Skip(i * chunkSize).Take(chunkSize).ToList())
            .ToList();
    }

    // 方法 3: 使用自定义方法
    static List<List<int>> SplitListCustom(List<int> originalList, int chunkSize)
    {
        List<List<int>> result = new List<List<int>>();
        
        for (int i = 0; i < originalList.Count; i += chunkSize)
        {
            result.Add(GetChunk(originalList, i, chunkSize));
        }

        return result;
    }

    // 自定义方法，获取指定索引和大小的子列表
    static List<int> GetChunk(List<int> originalList, int index, int chunkSize)
    {
        int count = Math.Min(chunkSize, originalList.Count - index);
        return originalList.GetRange(index, count);
    }

    // 打印拆分后的列表
    static void PrintSplittedLists(string method, List<List<int>> splittedLists)
    {
        Console.WriteLine($"=== {method} ===");

        foreach (var list in splittedLists)
        {
            Console.WriteLine($"[{string.Join(", ", list)}]");
        }

        Console.WriteLine();
    }
}

.net6里的方法：

var originalList = new List<int>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

// split into arrays of no more than three
IEnumerable<int[]> chunks = originalList.Chunk(3);

注意事项及建议

• 边界情况处理

  • 考虑原列表长度不能整除 N 的情况，确保不会引起索引溢出。

• 性能比较

  • 在实际使用中，可以通过性能测试比较不同方法的性能，选择最适合项目需求的方法。

• 列表元素类型

  • 考虑

原列表元素类型，确保自定义方法适用于不同类型的列表。

本文详细讨论了在C#中将列表拆分为 N 大小的较小列表的三种方法，并提供了相应的示例代码。通过手动拆分、使用LINQ的Skip和Take以及自定义方法，可以根据项目需求选择最适合的方法。在实际应用中，建议根据性能需求和代码清晰度来选择合适的拆分方式。