c# - 如何使 C# 中的侵入式树类使用泛型？

Question

在 C# 中，我有一个看起来像这样的侵入式树结构:

public abstract class Node
{
    Container parent;
    Node nextNode;
    Node previousNode;

    public abstract class Container : Node
    {
        Node firstChild;
        Node lastChild;
    }
}

可以添加到树中的各种对象继承自 Node 或 Container，具体取决于它们是否可以有 child 。

通过使 Container 成为内部类，这意味着它可以访问 Node 中的私有(private)成员以管理容器的子级列表。

这一切都很好。但现在我希望将它变成通用的，这样我可以在保持类型安全的同时重用它——基本上将所有树功能移动到 Node 之上的通用类和 Node 和 Container 之间的另一个。这是我正在尝试做的粗略设计:

public abstract class GenericNode<Node, Container>
    where Node : GenericNode<Node, Container>
    where Container : GenericNode<Node, Container>.GenericContainer
{
    Container parent;
    Node nextNode;
    Node previousNode;

    public abstract class GenericContainer : Node
    {
        Node firstChild;
        Node lastChild;
    }
}

当然，这不起作用，因为您不能使 GenericContainer 继承自 Node(编译器错误 CS0689)。即使我放弃了内部类要求(例如，通过使用 internal 并且只是在我自己的库中小心)我仍然无法找出不会遇到相同问题的设计(并且错误)。

(我不认为我必须这样做，但只是想说明一下:我不是要“修复”编译错误，我也不是在寻找简单的树实现。这是一道容器设计题。)

所以现在我有点难住了。有没有人对如何设计这个东西有更好的想法？

编辑:一定要看看this answer ，这是设计的另一个尝试，它试图使用扩展方法来避免将类“注入(inject)”到继承层次结构中的问题(但不幸的是，它并没有完全起作用)。

Answer 1

按照您的扩展方法方法，如果您改为在接口(interface)上定义继承约束(在 Node 和 Container 之间)，并使用该接口(interface)装饰容器类，会怎样。

{
    MyNode n = new MyNode();
    var c = new MyNode.MyContainer();
    c.AddChild(n);

    MySubNode s = new MySubNode();
    c.AddChild(s);

    OtherNode o = new OtherNode();
    o.AddChild(o);

    //compiler doesn't allow this, as you'd expect:
    //c.AddChild(o);
}        

public interface IContainer<TContainerType, TNodeType>
    where TNodeType : GenericNode<TContainerType, TNodeType>
    where TContainerType : TNodeType, IContainer<TContainerType, TNodeType>
{
}

public static class ContainerExtensions
{
    public static void AddChild<TContainerType, TNodeType>(this IContainer<TContainerType, TNodeType> self, TNodeType node)
        where TNodeType : GenericNode<TContainerType, TNodeType>
        where TContainerType : TNodeType, IContainer<TContainerType, TNodeType>
    {
        GenericNode<TContainerType, TNodeType>.AddChild(self as TContainerType, node);
    }
}

public class GenericNode<TContainerType, TNodeType>
    where TNodeType : GenericNode<TContainerType, TNodeType>
    where TContainerType : GenericNode<TContainerType, TNodeType>
{
    TContainerType parent;
    TNodeType nextNode;
    TNodeType previousNode;

    // Only used by Container
    TNodeType firstChild;
    TNodeType secondChild;

    internal static void AddChild(TContainerType container, TNodeType node)
    {
        container.firstChild = node;
        node.parent = container;
    }
}

public class MyNode : GenericNode<MyContainer, MyNode>
{        
}

public class MyContainer : MyNode, IContainer<MyContainer, MyNode>
{
}

public class MySubNode : MyNode
{
}

public class OtherNode : GenericNode<OtherNode, OtherNode>, IContainer<OtherNode, OtherNode>
{
}