嵌套 foreach 取决于前一个 foreach 的变量

Question

我已经编写了一段代码，可以正确地循环列表并执行我需要的操作，但我认为我的做法有点愚蠢，我正在寻找一种有效地编写此代码的方法，用一段时间，或者重复循环。

这是有效的：

            data = List<string>; //a new list of strings
            foreach (var string in data) 
            {
                data = createNewList(string); //for every string inside the previous, a new list is created
                foreach (var string2 in data) 
                {
                     data = createNewList(string2); //for every string in the last one, a new list is created
                    foreach (var string3 in data)
                    {
                         data = createNewList(string3);
                        foreach (var string4 in data)
                        {
                                //And so on...
                        }
                    }
                }
            }

我尝试的（使用真实代码）在第一次迭代后停止而没有错误......但我希望它能够无限，只要有一个子列表正在制作

            dataSingles = addFolderItemsList(sourcelist);
            foreach (NodeN node in dataSingles)
            {
               

                while (flag > 0)
                {
                    flag = 0;
                    foreach (NodeN subnode in dataSingles)
                    {
                        dataSingles = addFolderItemsList(subnode.ChildrenN);
                        if (dataSingles.Count() > 0) { flag = 1; }
                      
                    }
                   
                   
            }

Answer 1

所以基本上，您正在尝试执行一个嵌套循环，该循环遍历字符串（或元素）列表并根据前一个列表中的元素创建新列表。您使用嵌套 foreach 循环的初始方法不适合这种情况，因为您在循环内修改相同的 data 变量，这可能会导致意外行为。

根据您的描述，您似乎希望继续创建新的项目列表，直到不再生成任何子列表。您已尝试使用 while 循环来实现此目的，但实现有点偏差。

以下是如何使用 while 循环更有效地构建代码以实现所需的行为：

List<NodeN> dataSingles = addFolderItemsList(sourcelist);
int flag = 1; // Initialize flag to 1 to start the loop

while (flag > 0)
{
    flag = 0; // Reset the flag at the beginning of each iteration

    List<NodeN> newDataSingles = new List<NodeN>(); // Create a new list for the next level

    foreach (NodeN subnode in dataSingles)
    {
        List<NodeN> subnodeChildren = addFolderItemsList(subnode.ChildrenN);
        
        if (subnodeChildren.Count() > 0)
        {
            flag = 1; // Set the flag to 1 if there are sublists being generated
            newDataSingles.AddRange(subnodeChildren); // Add the sublists to the new list
        }
    }

    dataSingles = newDataSingles; // Update the list with the new sublists for the next iteration
}

在这段代码中，我们维护两个列表：dataSingles，它保存当前级别的节点，以及newDataSingles，它保存下一个级别的节点。只要有子列表生成（flag大于0），while循环就会继续。在每次迭代中，我们迭代当前级别的节点，生成子列表，并更新 newDataSingles 列表。最后，我们使用新的子列表更新 dataSingles 列表，以便进行下一次操作。

此方法可确保您不会修改正在迭代的同一列表，并且只要生成新的子列表，它就应该允许您有效地迭代列表的层次结构。

Answer 2

只需使用递归 ProcessList 函数即可迭代列表。

void ProcessList(List<string> data)
{
    List<string> newData = new List<string>();
    foreach (var item in data)
    {
        newData.AddRange(createNewList(item));
    }

    if (newData.Count > 0)
    {
        ProcessList(newData);
    }
}

ProcessList(data); 

如果您想使用 while 循环，请使用下面的代码片段，递归将是实现此解决方案的最佳方法，因此请记住这一点

List<string> currentData = data; 
while(currentData.Count > 0) 
{
    List<string> newData = new List<string>();
    foreach(var item in currentData) 
    {
        newData.AddRange(createNewList(item));
    }
    currentData = newData;
}