C# 递归地查找对象的子对象#

我想问你，通过父对象的每个子对象最有效的方法是什么。例如，我有一个类，它是：

public class Asset
{
    public string Id { get; set; }

    public Asset Child { get; set; }
}

static void Main(string[] args)
{
     var x = new Asset() { Id = "1" };
     var y = new Asset() { Id = "2" };
     var z = new Asset() { Id = "3" };

     x.Child = y;
     y.Child = z;
     z.Child = null;

     var listOfChildItems = new List<Asset>();
     listOfChildItems = GetAllChildren(x);
}

static List<Asset> GetAllChildren(Asset asset)
{
   // TODO:
}

公共类资产
{
公共字符串Id{get；set；}
公共资产子项{get；set；}
}
静态void Main（字符串[]参数）
{
var x=新资产（）{Id=“1”}；
var y=新资产（）{Id=“2”}；
var z=新资产（）{Id=“3”}；
x、 Child=y；
y、 Child=z；
z、 Child=null；
var listOfChildItems=新列表（）；
listOfChildItems=GetAllChildren（x）；
}
静态列表GetAllChildren（资产）
{
//待办事项：
}

此类可能包含包含另一个子类的子类，以此类推。所以我想要的是递归地获取子项的整个子项列表，直到子项不等于null。

static IEnumerable GetAllAssets（资产资产）
static IEnumerable<Asset> GetAllAssets(Asset asset)
{
    if (asset == null)
        yield break;

    yield return asset;
    foreach (Asset child in GetAllAssets(asset.Child))
        yield return child;
}

{
如果（资产==null）
屈服断裂；
资产收益率；
foreach（GetAllAssets（Asset.child）中的资产子级）
退换子女；
}

类别资产
{
公共资产子项{get；set；}=null；
}
静态void main（字符串[]参数）
{
列表子项=新列表（）；
资产=新资产（）；
while（asset.Child！=null）
{
asset=asset.Child；
添加（资产）；
}
//资产现在是最底层的子项
}

公共类资产
{
公共资产子项{get；set；}
公共列表GetChildren（）
{
返回GetChildrenInternal（new List（），this）；
}
私有列表GetChildrenInternal（列出子项、资产父项）
{
if（parent.Child？.Child！=null）
{
添加（parent.Child）；
GetChildrenInternal（children，parent.Child）；
}
返回儿童；
}
}

您尝试过什么？如果你想递归地遍历对象树，使用递归方法听起来是个好主意。具体来说，一个迭代器方法返回一个

IEnumerable

就可以了。最少的代码行数？最快执行时间？消耗的内存量最少？@HimBromBeere可能是这些参数中的每一个。通常情况下，您无法获得所有参数，如果您保存一些代码行，可能会花费您的时间、内存甚至可读性，反之亦然。这不是最有效的方法。我会说，由于递归、收益率和foreach循环，这是效率较低的方法。@MichałJarzyna为什么喜欢它？看一看：@Dongdong，因为它应该是

公共静态IEnumerable GetAllAssets（资产项）{while（item.Child！=null）{item=item.Child；yield return item；}}

Oh.编辑它吧。：-@Dongdong不，我不会。那会破坏Matthias的回答。“我不知道他会不会同意。”费尔多，你是怎么想的？它检查子项是否为null，将资产指定为非

null

的子项，然后将其添加到

children

IMHO，递归解决方案在这里是次优的。您可以不使用它，同时提高效率、可读性和缩短时间。

class Asset
{
    public Asset Child { get; set; } = null;
}

static void main (string[] args) 
{
     List<Asset> children = new List<Asset>();
     Asset asset = new Asset();
     while (asset.Child != null) 
     {
         asset = asset.Child;
         children.Add(asset);
     }
     //asset is now the bottom most child
}

public class Asset
{
    public Asset Child { get; set; }

    public List<Asset> GetChildren()
    {
        return GetChildrenInternal(new List<Asset>(), this);
    }

    private List<Asset> GetChildrenInternal(List<Asset> children, Asset parent)
    {
        if (parent.Child?.Child != null)
        {
            children.Add(parent.Child);
            GetChildrenInternal(children, parent.Child);
        }

        return children;
    }
}