Question

我设置了以下对象：

public class DrawingInstance
{
    public string DrawingNum;
    public string Rev;
    public string Title;
    public int LevelNum;
    public string RefDesc;
    public string DateRelease;
    public string DrawingType;
    public DrawingInstance ParentMember;
    public int PageInstance;

    public List<DrawingInstance> ChildMembers = new List<DrawingInstance>();
}

收集完所有数据后，我目前正在每个级别访问一个级别的成员，如下所示：

for (int i = 0; i < drawingInstance.ChildMembers.Count; i++)
{
    for (int j = 0; j < drawingInstance.ChildMembers[i].ChildMembers.Count; j++)
    {
        ....
        ....
    }
}

每次处理的文件中的级别数可能不同。

有没有办法通过递归循环遍历无限多个级别？我需要一次处理它们1级。因此，所有的i都将被处理，然后处理每个i的所有j，依此类推。目前我有10个代码块可以处理10个级别，但我觉得必须有更好的方法来解决这个问题。

修改感谢您的快速回复。以下是我的代码中更详细的外观，可以更深入地了解我当前如何处理对象

//Level 0 Pages
        int _pageNum = PageNum;
        int startIdx = 0;
        int pageCount = 0;
        pageCount = GetVisioPageCount(_treeArray.ChildMembers.Count);
        for (int i = 0; i < pageCount; i++)
        {
            VisioSheetOutline tempSheet = new VisioSheetOutline();
            tempSheet = GetSingleSheet(_treeArray, startIdx, _pageNum, (i + 1));
            for (int cMember = 0; cMember < tempSheet.ChildPairs.Length; cMember++)
            {
                ParentDictionary.Add(tempSheet.ChildPairs[cMember].SingleInstance, tempSheet.SheetName);
            }
            SheetList.Add(tempSheet);
            _pageNum++;
            startIdx += 15;
        }


        //Level 1 Pages
        for (int i = 0; i < _treeArray.ChildMembers.Count; i++)
        {
            pageCount = 0;
            pageCount = GetVisioPageCount(_treeArray.ChildMembers[i].ChildMembers.Count);
            startIdx = 0;
            for (int j = 0; j < pageCount; j++)
            {
                VisioSheetOutline tempSheet = new VisioSheetOutline();
                tempSheet = GetSingleSheet(_treeArray.ChildMembers[i], startIdx, _pageNum, (i + 1));
                for (int cMember = 0; cMember < tempSheet.ChildPairs.Length; cMember++)
                {
                    ParentDictionary.Add(tempSheet.ChildPairs[cMember].SingleInstance, tempSheet.SheetName);
                }
                SheetList.Add(tempSheet);
                _pageNum++;
                startIdx += 15;
            }
        }

        //Level 2 Pages
        for (int i = 0; i < _treeArray.ChildMembers.Count; i++)
        {
            for (int j = 0; j < _treeArray.ChildMembers[i].ChildMembers.Count; j++)
            {
                pageCount = 0;
                pageCount = GetVisioPageCount(_treeArray.ChildMembers[i].ChildMembers[j].ChildMembers.Count);
                startIdx = 0;
                for (int k = 0; k < pageCount; k++)
                {
                    VisioSheetOutline tempSheet = new VisioSheetOutline();
                    tempSheet = GetSingleSheet(_treeArray.ChildMembers[i].ChildMembers[j], startIdx, _pageNum, (i + 1));
                    for (int cMember = 0; cMember < tempSheet.ChildPairs.Length; cMember++)
                    {
                        ParentDictionary.Add(tempSheet.ChildPairs[cMember].SingleInstance, tempSheet.SheetName);
                    }
                    SheetList.Add(tempSheet);
                    _pageNum++;
                    startIdx += 15;
                }
            }
        }

我目前正在研究一些建议，以确定哪一个符合我的特殊需求。

Answer 1

是的，正如您的建议，您可以使用递归轻松处理此问题;你只需要一个递归函数：

public void ProcessDrawingData(DrawingInstance instance)
{
     // Do processing
     foreach (DrawingInstance d in ChildMembers)
         ProcessDrawingData(d);
}

使用父实例调用它。这不会做真正的广度优先遍历，因为第一个孩子将执行其第一个孩子（首先一直向下）并慢慢放松。

Answer 2

Microsoft的Ix-Main包中包含许多LINQ扩展，包括Expand方法，它将使分层布局变平：

IEnumerable<DrawingInstance> rootList = ...;
IEnumerable<DrawingInstance> flattened = rootList.Expand(x => x.ChildMembers);

Answer 3

您可以使用foreach() statement。这将迭代您需要的组，假设该对象实现了IEnumerable。

在你的情况下，试试这个：

foreach(DrawingInstance di in ChildMembers)
{
   // Do something with di.
}

修改

如果你需要重复这样做，你应该有一种带有DrawingInstance的递归方法，如下所示：

public void RecursiveMethod(DrawingInstance d) { foreach(DrawingInstance di in d.ChildMembers) { RecursiveMethod(di); } }

我不了解你的项目，所以由你决定基本情况，或者这个递归编辑是你真正想要的。

是否有某种算法可以继续循环通过未知数量的子成员？

3 个答案: