遍历层次对象c#

如果我有下面这样的课。如何遍历它直到其属性SomeObjects.count=0

public class SomeObject
{
  public String Name { get; set; }
  public List<SomeObject> SomeObjects { get; set; }
}

公共类SomeObject
{
公共字符串名称{get；set；}
公共列表SomeObjects{get；set；}
}

---

非常感谢

这是一个树状结构；有很多算法可以遍历它，你可以也可以找到很多算法。

下面是一个如何遍历复合对象的通用示例：

public static class TraversalHelper{

    public static void TraverseAndExecute<T>(this T composite, Func<T,IEnumerable<T>> selectChildren, Action<T> action)
        where T: class
    {
         action.Invoke(composite);
         composite.TraverseAndExecute(selectChildren, action, new List<T>{ composite });
    }

    private static void TraverseAndExecute<T>(this T composite, Func<T,IEnumerable<T>> selectChildren, Action<T> action, IList<T> invokedComponents)
        where T: class
    {
        invokedComponents = invokedComponents ?? new List<T>();
        var components = selectChildren(composite) ?? new T[]{};
        foreach(var component in components){
            // To avoid an infinite loop in the case of circular references, ensure 
            // that you don't loop over an object that has already been traversed
            if(!invokedComponents.Contains(component)){
                action.Invoke(component);
                invokedComponents.Add(component);
                component.TraverseAndExecute<T>(selectChildren, action, invokedComponents);
            }
            else{
                // the code to execute in the event of a circular reference
                // would go here
            }
        }
    }
}

公共静态类遍历帮助器{
public static void transverseandexecute（此T组合，Func selectChildren，Action）
T:在哪里上课
{
action.Invoke（复合）；
TraverseAndExecute（selectChildren，action，new List{composite}）；
}
私有静态void transverseandexecute（此T组合、Func selectChildren、Action、IList invokedComponents）
T:在哪里上课
{
invokedComponents=invokedComponents？？新建列表（）；
var components=selectChildren（复合）？？新的T[]{}；
foreach（组件中的var组件）{
//要避免循环引用中出现无限循环，请确保
//不要在已经遍历的对象上循环
如果（！invokedComponents.Contains（组件））{
调用（组件）；
invokedComponents.Add（组件）；
TraverseAndExecute（选择子项、操作、调用的组件）；
}
否则{
//循环引用事件中要执行的代码
//我会去这里
}
}
}
}

下面是一个示例用法：

public class Program{
    public static void Main(){
   var someObject = new SomeObject { 
                        Name = "Composite",
                        SomeObjects = new List<SomeObject>{
                            new SomeObject{ Name = "Leaf 1" },
                            new SomeObject{ 
                                Name = "Nested Composite",
                                SomeObjects = new List<SomeObject>{ new SomeObject{Name = "Deep Leaf" }}
                            }
                        }
                    };
   someObject.TraverseAndExecute(      
                      x => x.SomeObjects, 
                      x => { Console.WriteLine("Name: " + x.Name); }
       );
    }
}

公共类程序{
公共静态void Main（）{
var someObject=新的someObject{
Name=“Composite”，
SomeObjects=新列表{
新建SomeObject{Name=“Leaf 1”}，
新对象{
Name=“嵌套复合”，
SomeObjects=新列表{new SomeObject{Name=“Deep Leaf”}
}
}
};
someObject.TraverseAndExecute（
x=>x.SomeObjects，
x=>{Console.WriteLine（“Name:+x.Name）；}
);
}
}

SomeObjects=0是什么意思？有几个选项可以循环浏览列表。请澄清你的问题。这是一个模糊的问题，很清楚你有什么问题。您是在问如何编写递归函数吗？还是需要按特定顺序遍历对象？到目前为止你都试了些什么？我指的是TreeThank，这就是我要找的。@niju，很高兴我能帮上忙。您可以通过单击目标答案帖子左上角的复选标记来选择答案。这是否也会迭代可枚举成员？@luisferro，

selectChildren

参数是选择可枚举成员的委托。

foreach

子句遍历结果可枚举表中的每个元素。