C# 当我'；我正在处理多种数据类型

我有一个问题困扰了我一段时间，它关系到我的程序中循环的指数增长。我将让下面的代码进行对话，并在其中添加注释

void Main()
{
    //Here we are just creating simple lists
    List<string> strings = new List<string>();
    strings.Add("a");
    strings.Add("b");
    strings.Add("c");

    List<int> integers = new List<int>();
    integers.Add(1);
    integers.Add(2);
    integers.Add(3);

    //Creating complex classes ( not really )
    ComplexClass cc1 = new ComplexClass();
    cc1.CCString = "A test";
    cc1.CCInt = 2;

    ComplexClass cc2 = new ComplexClass();
    cc2.CCString = "Another test";
    cc2.CCInt = 6;

    //Creating a list of these too
    List< ComplexClass > complexClasses = new List< ComplexClass >();
    complexClasses.Add(cc1);
    complexClasses.Add(cc2);


    //Here i want to create every possible combination using each of the lists 
    //and then add these to a testData class to do other things with, serialize, save, print etc.
    //The main question is here, the for loops will definitely increase exponentially with each
    //list added to. 
    foreach( int i in integers )
    {
        foreach( string s in strings )
        {
            foreach( ComplexClass compClass in complexClasses )
            {
                TestData data = new TestData();
                data.TestInteger = i;
                data.TestString = s;
                data.TestComplexClass = compClass;

                OutPutTestData( data );
            }
        }
    }
}

//Simply outputs the data as test but I will be keeping the object for later also
public void OutPutTestData( TestData testData )
{
    Console.WriteLine( testData.TestString + testData.TestInteger + testData.TestComplexClass.CCString );
}

//The "Complex class" again not that complex but an example of what im tring to achieve
public class ComplexClass
{
    public string CCString{ get; set; }
    public int CCInt { get; set; }
}

//The overall test object which holds multiple properties of different data types
public class TestData
{
    public string TestString { get; set; }
    public int TestInteger { get; set; }
    public ComplexClass TestComplexClass { get; set; }
}

void Main（）
{
//这里我们只是创建简单的列表
列表字符串=新列表（）；
字符串。添加（“a”）；
字符串。添加（“b”）；
字符串。添加（“c”）；
列表整数=新列表（）；
整数。加（1）；
整数。加（2）；
整数。加（3）；
//创建复杂类（不是真的）
ComplexClass cc1=新的ComplexClass（）；
cc1.CCString=“测试”；
cc1.CCInt=2；
ComplexClass cc2=新的ComplexClass（）；
cc2.CCString=“另一项测试”；
cc2.CCInt=6；
//也要创建一个列表
ListComplexClass=新列表（）；
complexClasses.Add（cc1）；
complexClasses.Add（cc2）；
//在这里，我想使用每个列表创建每个可能的组合
//然后将它们添加到testData类中，以执行其他操作，如序列化、保存、打印等。
//这里的主要问题是，for循环肯定会随着时间的推移呈指数增长
//列表已添加到。
foreach（整数中的整数i）
{
foreach（字符串中的字符串s）
{
foreach（ComplexClass中的ComplexClass）
{
TestData数据=新的TestData（）；
data.TestInteger=i；
data.TestString=s；
data.TestComplexClass=compClass；
输出数据（数据）；
}
}
}
}
//只需将数据作为测试输出，但我也将保留该对象以备以后使用
public void OutPutTestData（TestData TestData）
{
Console.WriteLine（testData.TestString+testData.TestInteger+testData.TestComplexClass.CCString）；
}
//“复杂类”也不是那么复杂，而是我想要实现的一个例子
公共类ComplexClass
{
公共字符串CCString{get；set；}
公共int CCInt{get；set；}
}
//包含不同数据类型的多个属性的总体测试对象
公共类测试数据
{
公共字符串TestString{get；set；}
public int TestInteger{get；set；}
公共ComplexClass TestComplexClass{get；set；}
}

输出

a1测试1

a1测试2

b1测试1

b1测试2

c1测试1

c1测试2

a2测试1

a2测试2

b2测试1

b2测试2

c2测试1

c2测试2

a3测试1

a3测试2

b3测试1

b3测试2

c3测试1

c3测试2

正如您所看到的，循环工作，并为我提供了所提供数据的所有可能组合

我的问题是当我添加更多列表时for循环的指数增长。可能有大量的列表

我知道迭代次数会随着组合的发现而增加，这不是问题，因为我计划在估计可能的总迭代次数后，根据用户输入以编程方式限制迭代次数

e、 g.总迭代次数为234次，因此仅迭代120次（120个组合）

提供的代码在嵌套的foreach循环中工作得很好，但是随着它的指数增长，它变得很难阅读、很难管理，而且通常很难看

我研究过如下排列算法：

但它们只允许使用一种特定的数据类型，而不允许使用多种数据类型

---

我还研究了笛卡尔积，但我发现的唯一示例仅涉及一种数据类型

您可以通过在Linq中执行交叉连接来摆脱for循环：

var query = 
    from  i in integers
    from s in strings 
    from compClass in complexClasses
    select new TestData()
    {
        TestInteger = i,
        TestString = s,
        TestComplexClass = compClass
    };

foreach (var data in query)
    OutPutTestData( data );

---

如果列表都是相同类型的，那么您可以构建一个交叉连接不同数量列表的查询。在您的情况下，由于列表的类型不同，因此不可能（没有反射、动态或更丑陋的东西）

即使您选择了一个答案，我想您可能想看看这个。。。使用递归，您所要做的就是将所有的

列表

放在

列表

中。您只需将任何新添加的

列表

添加到

列表

我在您的

ComplexClass

中添加了一个

override-ToString（）

，以适应此要求

        public static void Test()
        {
            //Here we are just creating simple lists
            List<string> strings = new List<string>();
            strings.Add("a");
            strings.Add("b");
            strings.Add("c");

            List<int> integers = new List<int>();
            integers.Add(1);
            integers.Add(2);
            integers.Add(3);

            //Creating complex classes ( not really )
            ComplexClass cc1 = new ComplexClass();
            cc1.CCString = "A test";
            cc1.CCInt = 2;

            ComplexClass cc2 = new ComplexClass();
            cc2.CCString = "Another test";
            cc2.CCInt = 6;

            //Creating a list of these too
            List<ComplexClass> complexClasses = new List<ComplexClass>();
            complexClasses.Add(cc1);
            complexClasses.Add(cc2);

            // NEW LIST
            List<double> doubles = new List<double>();
            doubles.Add(99.99);
            doubles.Add(100.12);

            List<IList> myLists = new List<IList> {integers, strings, complexClasses, doubles};
            Permutate("", myLists, 0);

            Console.ReadLine();
        }

        public static void Permutate(string s, List<IList> list, int i)
        {
            if (i == list.Count)
            {
                Console.WriteLine(s);
            }
            else
            {
                foreach (object obj in list[i])
                {
                    Permutate(s + obj + " ", list, i + 1);
                }
            }
        }

        //The "Complex class" again not that complex but an example of what im tring to achieve
        public class ComplexClass
        {
            public string CCString { get; set; }
            public int CCInt { get; set; }

            // Added override
            public override string ToString()
            {
                return CCString + CCInt;
            }
        }

公共静态无效测试（）
{
//这里我们只是创建简单的列表
列表字符串=新列表（）；
字符串。添加（“a”）；
字符串。添加（“b”）；
字符串。添加（“c”）；
列表整数=新列表（）；
整数。加（1）；
整数。加（2）；
整数。加（3）；
//创建复杂类（不是真的）
ComplexClass cc1=新的ComplexClass（）；
cc1.CCString=“测试”；
cc1.CCInt=2；
ComplexClass cc2=新的ComplexClass（）；
cc2.CCString=“另一项测试”；
cc2.CCInt=6；
//也要创建一个列表
List complexclass=new List（）；
complexClasses.Add（cc1）；
complexClasses.Add（cc2）；
//新名单
List doubles=新列表（）；
双倍。加（99.99）；
双倍。加上（100.12）；
List myLists=新列表{整数、字符串、复合类、双精度}；
置换物（“”，糜棱岩，0）；
Console.ReadLine（）；
}
公共静态void置换（字符串s、列表列表、int i）
{
if（i==list.Count）
{
控制台。写入线（s）；
}
其他的
{
foreach（列表[i]中的对象obj）
{
置换（s+obj+“”，list，i+1）；
}
}
}
//“复杂类”也不是那么复杂