C# 使用LAMBDA表达式获取具有相同类型的对象的对象树的深度

我有一个目标：

public class dtHeader
{
    public dtHeader ParentHeader { get; set; }
    public string HeaderText { get; set; }
    public string DataField { get; set; }
    public bool Visible { get; set; }
    public int DisplayOrder { get; set; }
}

我想用lambda表达式计算物体的深度，物体本身有多少层

我看到了，但我正在努力将其转换为一行lambda语句

假设对象是这样的

newdtheader（）{ParentHeader=null，HeaderText=“col1”}
结果是1

对于
newdtheader（）{ParentHeader=newdtheader（）{ParentHeader=null，HeaderText=“col1”}，HeaderText=“col1”}结果将是2

我想通过一个
列表
来实现这一点，因此其中一些列表的深度为1，而另一些列表的深度更深，并且需要最深的深度

    _______ITEM_IN_LIST_OBJECT__
    ______1___2___3___4___5___6_
 D  1.  |_o_|_o_|_o_|_o_|_o_|_o_|
 E  2.  |_o_|___|_o_|___|_o_|_o_|
 P  3.  |___|___|_o_|___|_o_|___|
 T  4.  |___|___|___|___|_o_|___|
 H  5.  |___|___|___|___|_o_|___|

它必须无限深（直到它允许对象彼此堆积在一起）

编辑：
我只想补充一点，如果你想在一个特定的深度级别上工作，例如，深度为3的所有对象，你可以在类中使用这个额外的递归函数

public class dtCol
{
    public dtCol ParentHeader { get; set; }
    public string HeaderText { get; set; }
    public string DataField { get; set; }
    public bool Visible { get; set; }
    public int DisplayOrder { get; set; }
    public int Depth { get { return ParentHeader != null ? ParentHeader.Depth + 1 : 1; } }
    public int CurrentDepth { get; set; } //Set on initialisation
    public dtCol getParent(dtCol col, int getDepth) //Gets the parent on a specific level after the first base level (1) else returns the previous not null child
    {
        return (col.ParentHeader != null && col.ParentHeader.CurrentDepth == getDepth) ? col.ParentHeader : this.getParent(col.ParentHeader, getDepth);
    }
}

您可以这样使用它：

var HeaderLayerCount = lDtCol.OrderByDescending(n => n.Depth).First().Depth;
for (int hlc = 1; hlc <= HeaderLayerCount; hlc++)
{
    var headerrow = new List<dtCol>();
    //This foreach adds the parent header if not null else adds the not null child
    lDtCol.ForEach(n =>
    {
        var h = n.getParent(n, hlc); //Get Parent, null is returned if parent does not exists
        headerrow.Add((h != null) ? h : n); //If parent is null, add base dtCol so that the headers can be merged upwards.
    });

    //Do what you need with your new single dimensional list of objects
}

var HeaderLayerCount=lDtCol.OrderByDescending（n=>n.Depth）.First（）.Depth；
对于（int hlc=1；hlc
{
var h=n.getParent（n，hlc）；//获取父项，如果父项不存在，则返回null
headerrow.Add（（h！=null）？h:n）；//如果parent为null，则添加base dtCol，以便可以向上合并头。
});
//使用新的一维对象列表执行所需操作
}
为什么不在类上实现一个int-GetDepth（）方法，该方法将到达最顶层的祖先，计算每个级别

这样，您的查询就会简单得多

我被弗罗德打败了，这是他应得的荣誉

我有同样的实现：

 public int GetDepth()
        {
            if (ParentHeader == null)
            {
                return 1;
            }
            else return 1 + ParentHeader.GetDepth();
        }

下面是一个lambda表达式，用于获取所需的内容：

Func<dtHeader, int> getDepth = null;
getDepth = dth =>
{
    var depth = 1;
    if (dth.ParentHeader != null)
    {
        depth += getDepth(dth.ParentHeader);
    }
    return depth;
};

Func getDepth=null；
getDepth=dth=>
{
var深度=1；
if（dth.ParentHeader！=null）
{
深度+=getDepth（dth.ParentHeader）；
}
返回深度；
};

您必须将其定义为两个部分（赋值
null
&赋值主体）才能让递归工作。
我修改了Enigmativity的答案以使其正确工作：

Func<dtHeader, int, int> getDepth = null;
getDepth = (dth, depth) =>
{
    if (dth.ParentHeader != null)
    {
        depth = getDepth(dth.ParentHeader, ++depth);
    }

    return depth;
};

这听起来是个很好的主意，你能不能举个例子来说明你将如何做？谢谢你的回答。这将永远返回1。您需要将depth传递给getDepth Functoo@jabko87-不，此功能工作正常。这个想法是它返回深度-它不需要传递它来做这件事。这是完全不必要的。我的函数运行得很好。你的代码实际上是错的。您正在调用
getDepth（header，0）
，它将返回比所需值少1的值。代码要求调用方知道初始深度。
Func<dtHeader, int> getDepth = null;
getDepth = dth =>
{
    var depth = 1;
    if (dth.ParentHeader != null)
    {
        depth += getDepth(dth.ParentHeader);
    }
    return depth;
};

Func<dtHeader, int, int> getDepth = null;
getDepth = (dth, depth) =>
{
    if (dth.ParentHeader != null)
    {
        depth = getDepth(dth.ParentHeader, ++depth);
    }

    return depth;
};

int depth = getDepth(header, 0)