如何生成多个List/数组的所有元素组合？

实现思路 #

你需要的是生成多个列表各取一个元素的所有唯一组合，这本质是求集合的笛卡尔积。下面给两种实用的实现方案，适配不同场景：

方式一：嵌套循环（固定列表数量专用） #

因为你明确是3个列表，用三层嵌套循环最直接，逻辑清晰，容易上手。

using System;
using System.Collections.Generic;
using System.IO;

class Program
{
    static void Main()
    {
        List<string> list1 = new List<string> { "A1", "B1", "C1" };
        List<string> list2 = new List<string> { "A2", "B2" };
        List<string> list3 = new List<string> { "A3", "B3", "C3" };

        // 指定输出文件路径
        string outputFile = "combinations.txt";

        // 用StreamWriter写入文件，自动释放资源
        using (StreamWriter writer = new StreamWriter(outputFile))
        {
            // 遍历第一个列表的每个元素
            foreach (string item1 in list1)
            {
                // 遍历第二个列表的每个元素
                foreach (string item2 in list2)
                {
                    // 遍历第三个列表的每个元素，生成组合
                    foreach (string item3 in list3)
                    {
                        string line = $"{item1}, {item2}, {item3}";
                        writer.WriteLine(line);
                    }
                    // 和你的示例格式一致，每个list2元素的组合后加空行
                    writer.WriteLine();
                }
            }
        }

        Console.WriteLine($"所有组合已保存到 {outputFile}");
    }
}

方式二：通用笛卡尔积方法（支持任意数量列表） #

如果以后可能增加更多列表，这个方法不用改循环层数，扩展性更强。

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

class Program
{
    static void Main()
    {
        // 把所有列表放到一个大集合里
        List<List<string>> allLists = new List<List<string>>
        {
            new List<string> { "A1", "B1", "C1" },
            new List<string> { "A2", "B2" },
            new List<string> { "A3", "B3", "C3" }
        };

        string outputFile = "combinations.txt";

        // 计算所有列表的笛卡尔积
        var allCombinations = GetCartesianProduct(allLists);

        using (StreamWriter writer = new StreamWriter(outputFile))
        {
            int thirdListCount = allLists[2].Count;
            int counter = 0;

            foreach (var combo in allCombinations)
            {
                // 把组合元素用逗号拼接成一行
                writer.WriteLine(string.Join(", ", combo));
                counter++;

                // 每写完第三个列表的一组元素，添加空行
                if (counter == thirdListCount)
                {
                    writer.WriteLine();
                    counter = 0;
                }
            }
        }

        Console.WriteLine($"所有组合已保存到 {outputFile}");
    }

    // 通用笛卡尔积计算函数，支持任意类型的列表
    static IEnumerable<IEnumerable<T>> GetCartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
    {
        IEnumerable<IEnumerable<T>> result = new[] { Enumerable.Empty<T>() };
        foreach (var sequence in sequences)
        {
            result = from existingSeq in result
                     from item in sequence
                     select existingSeq.Concat(new[] { item });
        }
        return result;
    }
}

关键说明 #

• 嵌套循环适合列表数量固定的场景，代码简单直观，新手也能快速理解调试。
• 通用方法用LINQ实现，不管以后加多少个列表，只需要把新列表加到allLists里就行，不用改核心逻辑。
• 文件写入用using包裹StreamWriter，能自动释放文件资源，避免占用问题。
• 代码里已经处理了和你示例一致的格式：每个第二个列表元素对应的组合后加空行。如果不需要空行，删掉对应的writer.WriteLine()就行。

内容的提问来源于stack exchange，提问作者Bella Smith