Question

我有IList<Category>

类别类型来自SQL Server中的类别表：

表：类别

CategoryID，ParentCategoryID

在一张桌子中如此典型的层次结构。

因此，如果我有这个包含节点关系的类别的IList，那么我试图弄清楚这是如何适合制作像很多人一样的节点和树。构造函数看起来如何，并根据用法创建此类？

我对Generics来说并不是很难对付我。我认为在这里创建一个通用的Node类和Tree类是有道理的，所以我可以在将来重用我认为其他树类型。

所以，如果我有这样的东西，T如何被使用以及我从中获益？

（这里是伪代码）

public class Node<T>
...
    Node<T> _parentNode;
    List<Node<T>> _children;

    private void SetParentNode(T)
    private void AddChild(T)

... etc.

尝试理解这里的概念，为什么Generic Node类将用于包含子/父关系（int Ids）的Childeren等进入的任何类型

更新

因此在GroupBy建议中遇到问题。看看我试图用你的例子做什么：

首先，我在Tree类中拥有此属性：

public Dictionary，IList＆gt;＆gt; ParentNodeAndRelatedChildrenFlattenedMap {get;私人集; }

并且传入我的类的构造函数是一个IList依赖项，我将其转换（循环并为它们中的每一个创建一个新节点）到IList＆gt;

现在我正在尝试通过Node.ParentId对该列表进行分组，以便我在父节点上进行分组，并且由于每个节点都有其子属性，因此很容易找出相关子节点对这些父节点的影响节点

但是现在我的代码中出现了问题：

public void CreateFlattenedMap()
{
    var parentGroups = _nodeDependencies.GroupBy(d => d.ParentNodeId);

    var dictionary = parentGroups.ToDictionary(d => d, d => d.ToList());

    ParentNodeAndRelatedChildrenFlattenedMap = dictionary;
}

好吧，它不喜欢我的字典分配，因为它是一个＆gt;由ToDictionary（）创建的字典。因此，不确定如何将此分组分组，并将字典设为a，List＆gt;字典中的节点是我正在分组的父节点的节点实例（是的，我在其Node.ParentId上进行分组，但我最终想要节点在ToDictionary中）和List＆gt;是来自Parent Node.Children属性的子节点列表。

Answer 1

这是一个更完整的实现：

public class TreeNode<T>
{
    private T _item;
    private TreeNode<T> _parentNode;
    private List<TreeNode<T>> _children;

    public TreeNode(T item)
    {
        _item = item;
    }

    public void SetParentNode(T parent)
    {
        _parentNode.Item = parent;
    }

    public T Item
    {
        get { return _item; }
        set { _item = value; }
    }

    public void AddChild(T child)
    {
        _children.Add(new TreeNode<T>(child));
    }

    public void RemoveChild(T child)
    {
        var node = _children.FirstOrDefault(e => e.Item.Equals(child));
        if (node != null)
            _children.Remove(node);
    }
}

您的问题：

构造函数的外观如何，并根据使用情况创建此类？

正如您在上面AddChild()中所看到的，只需指定构造函数的子类型。

var node = new TreeNode<T>(item);

所以，如果我有这样的话，T如何被使用以及我从中受益？

使用泛型可以在完成正确的时候重写代码。在上面的实现中，我们可以通过简单地更改T来创建基本上我们想要的任何类型的树结构。因此，如果我们需要多种类型的树结构，这可以为我们节省大量时间。

var intTreeNode = new TreeNode<int>(10);
var stringTreeNode = new TreeNode<string>("hello world");

一般来说，在点击之前确实需要一些曝光时间，而你“只是得到它”，坚持下去。

构建树

要从可能有也可能没有父类别的类别列表构造树，您需要以某种方式遍历列表。一个体面的方法是首先将它们组织成基于ParentCategoryID的分组并构建树。像这样（未经测试）：

public List<TreeNode<Category>> ConstructCategories(List<Category> categories)
{
    var groups = categories.GroupBy(e => e.ParentCategoryID);
    var rootGroup = groups.Single(e => e.Key == null);
    var categories = List<TreeNode<Category>>();

    foreach (var category in rootGroup)
    {
        // Create and fill category
        var node = new TreeNode<Category>(category);
        ConstructChildrenCategories(node, groups);
        categories.Add(node);
    }
}

public void ConstructChildrenCategories(TreeNode<Category> node, IEnumerable<IGrouping<Category>> groups)
{
    var group = groups.Single(e => e.Key == node.Item.CategoryID);

    foreach (var category in group)
    {
        // Create and fill category
        var childNode = new TreeNode<Category>(category);
        ConstructChildrenCategories(childNode, groups);

        // We could do this automatically in both methods.
        childNode.SetParent(node.Item);
        node.AddChild(childNode);
    }
}

Answer 2

这可能会有所帮助：

public interface ICategory
{
    int Id { get; }
    int ParentId { get; }
}

public class Category : ICategory
{
    int id;
    int parentId;

    public int Id { get { return id; }}
    public int ParentId { get { return parentId; }}
}

这是Node类：

public class Node<T> where T : ICategory
{
    Node<T> _parentNode;
    List<Node<T>> _children;

    public Node<T> Parent { get { return _parentNode; }}

    public Node<T> Child(int index) { return _children[index]; }

    public T Value;

    public Node(T value)
    {
        this.Value = value;
    }

    public void AddChild(T item)
    {
        Node<T> child = new Node<T>(item);
        this._children.Add(child);
        child._parentNode = this;
    }
}

这是Tree类：

public class Tree<T> where T : ICategory
{
    List<Node<T>> values;

    public Tree()
    {
        this.values = new List<Node<T>>();
    }

    public Node<T> FindNode(int id)
    {
        if (values.Exists(input => input.Value.Id == id))
        {
            return values.Find(input => input.Value.Id == id);
        }
        else { return null; }

    }

    public void AddNode(T value)
    {
        Node<T> parent = FindNode(value.ParentId);

        if (parent != null)
        {
            parent.AddChild(value);
        }
    }
}

Answer 3

你不能完成树和treenode的所有功能。

而是将类数据添加到Treenode。

例如

class MyClass
{
    public int A;
    public string B;
}

...

TreeNode Node = TreeView.Nodes.Add("AAA");
MyClass Data = new MyClass();
Node.Tag = Data;

不会删除分配给TreeNode的数据。你也可以使用整个树属性和节点成员。

在使用节点数据时，唯一应该做的就是进行类型转换。

TreeNode Node = TreeView.Nodes[0];
MyClass Temp = Node.Tag as MyClass;

如何形成我的节点和树通用类

3 个答案:

构建树