C# 我想让自定义方法成为处理T类型的通用方法

我有两种方法

public static void NavigateAndExecute(Node root, Action<Node> actionToExecute)
{
    if (root == null || root.Children == null || root.Children.Count == 0)
        return;
    actionToExecute(root);
    foreach (var node in root.Children)
    {
        actionToExecute(node);
        NavigateAndExecute(node, actionToExecute);
    }
}
public static void NavigateAndExecute(List<Node> root, Action<Node> actionToExecute)
{
    if (root == null || root.Count == 0)
        return;
    foreach (var node in root)
    {                
        NavigateAndExecute(node, actionToExecute);
    }
}

publicstaticvoidnavigateandexecute（节点根，Action-actionToExecute）
{
if（root==null | | root.Children==null | | root.Children.Count==0）
返回；
actionToExecute（根）；
foreach（root.Children中的var节点）
{
actionToExecute（节点）；
NavigateAndExecute（节点，actionToExecute）；
}
}
公共静态void NavigateAndExecute（列表根、操作actionToExecute）
{
if（root==null | | root.Count==0）
返回；
foreach（根中的var节点）
{                
NavigateAndExecute（节点，actionToExecute）；
}
}

节点类是

public class Node
{
    public String Name { get; set; }
    public List<Node> Children { get; set; }
}

公共类节点
{
公共字符串名称{get；set；}
公共列表子项{get；set；}
}

这两个方法仅适用于Node类，可以使它们适用于任何类型的T

---

任何帮助。

我看到您正在访问

节点.Children

，它似乎是

节点

类特有的属性。因此，您的代码不能简单地通过将方法转换为泛型方法来工作

但是，您可以使用以下常规约束来实现这一点：

public static void NavigateAndExecute<T>(List<T> root, Action<T> actionToExecute) where T: Node

publicstaticvoidnavigateandexecute（List root，Action-actionToExecute），其中T:Node

我看到您正在访问

节点.Children

，它似乎是

节点

类特有的属性。因此，您的代码不能简单地通过将方法转换为泛型方法来工作

但是，您可以使用以下常规约束来实现这一点：

public static void NavigateAndExecute<T>(List<T> root, Action<T> actionToExecute) where T: Node

publicstaticvoidnavigateandexecute（List root，Action-actionToExecute），其中T:Node

您可以为

IEnumerable

创建一个静态扩展方法，该方法采用子选择器

Func

：

---

您可以为

IEnumerable

创建一个静态扩展方法，该方法采用子选择器

Func

：

---

我想你想要我以前实施过的东西。注意在main方法中使用了新属性

Name2

public static class Tree<N>
    where N : Tree<N>.Node
{
    public class Node
    {
        public String Name { get; set; }
        public List<N> Children { get; set; } 
    }

    public static void NavigateAndExecute(N root, Action<N> actionToExecute)
    {
        if (root == null)
            return;
        actionToExecute(root);

        if (root.Children == null || root.Children.Count == 0)
            return;
        NavigateAndExecute(root.Children, actionToExecute);
    }

    public static void NavigateAndExecute(List<N> root, Action<N> actionToExecute)
    {
        if (root == null || root.Count == 0)
            return;
        foreach (var node in root)
        {
            NavigateAndExecute(node, actionToExecute);
        }
    } 

}

public class Node2 : Tree<Node2>.Node
{
    public string Name2 { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var root = new Node2();
        Tree<Node2>.NavigateAndExecute(root, n => {
            Console.WriteLine(n.Name2);
        });
    }
}

公共静态类树
其中N:Tree.Node
{
公共类节点
{
公共字符串名称{get；set；}
公共列表子项{get；set；}
}
公共静态void NavigateAndExecute（N根，Action-actionToExecute）
{
if（root==null）
返回；
actionToExecute（根）；
if（root.Children==null | | root.Children.Count==0）
返回；
NavigateAndExecute（root.Children，actionToExecute）；
}
公共静态void NavigateAndExecute（列表根、操作actionToExecute）
{
if（root==null | | root.Count==0）
返回；
foreach（根中的var节点）
{
NavigateAndExecute（节点，actionToExecute）；
}
} 
}
公共类Node2:Tree.Node
{
公共字符串名称2{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
var root=新节点2（）；
Tree.NavigateAndExecute（根，n=>{
控制台写入线（n.Name2）；
});
}
}

我想你想要我以前实现的东西。注意在main方法中使用了新属性

Name2

public static class Tree<N>
    where N : Tree<N>.Node
{
    public class Node
    {
        public String Name { get; set; }
        public List<N> Children { get; set; } 
    }

    public static void NavigateAndExecute(N root, Action<N> actionToExecute)
    {
        if (root == null)
            return;
        actionToExecute(root);

        if (root.Children == null || root.Children.Count == 0)
            return;
        NavigateAndExecute(root.Children, actionToExecute);
    }

    public static void NavigateAndExecute(List<N> root, Action<N> actionToExecute)
    {
        if (root == null || root.Count == 0)
            return;
        foreach (var node in root)
        {
            NavigateAndExecute(node, actionToExecute);
        }
    } 

}

public class Node2 : Tree<Node2>.Node
{
    public string Name2 { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var root = new Node2();
        Tree<Node2>.NavigateAndExecute(root, n => {
            Console.WriteLine(n.Name2);
        });
    }
}

公共静态类树
其中N:Tree.Node
{
公共类节点
{
公共字符串名称{get；set；}
公共列表子项{get；set；}
}
公共静态void NavigateAndExecute（N根，Action-actionToExecute）
{
if（root==null）
返回；
actionToExecute（根）；
if（root.Children==null | | root.Children.Count==0）
返回；
NavigateAndExecute（root.Children，actionToExecute）；
}
公共静态void NavigateAndExecute（列表根、操作actionToExecute）
{
if（root==null | | root.Count==0）
返回；
foreach（根中的var节点）
{
NavigateAndExecute（节点，actionToExecute）；
}
} 
}
公共类Node2:Tree.Node
{
公共字符串名称2{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
var root=新节点2（）；
Tree.NavigateAndExecute（根，n=>{
控制台写入线（n.Name2）；
});
}
}

您需要一个通用树集合。一年前我写了一篇开源文章：

---

我知道反对使用树数据结构的理由，但有时它们正是您所需要的。

您需要一个通用的树集合。一年前我写了一篇开源文章：

---

我知道反对使用树型数据结构的理由，但有时它们正是你所需要的。

当不是所有类型都有

Children

属性时，它们如何处理任何类型的

T

？当不是所有类型都有

Children

属性时，它们如何处理任何类型的

T

？