如标题所述,我想知道是否有可能.

我有一个节点类,它指向同一数据结构中的另一个节点.

class DataStructure<T, N>
  where T : IComparable<T>
  where N : Node<T> {
    N RootNode;

    // More code to follow, etc.
}

class Node<T>
  where T : IComparable<T> {
    T value;
    Node<T> NextNode;

    Node<T> GetLastNode() {
        Node<T> current = this;
        while (this.NextNode != null) {
            current = current.NextNode;
        }
        return current;
    }

    // etc.
}

我希望能够扩展Node类,以便获得有关DataStructure某些常规版本的更多信息.例如：

class AdvancedNode<T> : Node<T>
  where T : IComparable<T> {
    int Height;
    int Size;
    // etc.
}

问题是当我尝试跟随NextNode链接时.

DataStructure<char, AdvancedNode<char>> d = new DataStructure<char, AdvancedNode<char>>();
d.RootNode = new AdvancedNode<char>();
d.RootNode.NextNode = new AdvancedNode<char>();
AdvancedNode<char> y = d.RootNode.NextNode;    // TYPE ERROR! Will not compile

另外,我想这样做,以致无法执行以下操作：

DataStructure<char, AdvancedNode<char>> d = new DataStructure<char, AdvancedNode<char>>();
d.RootNode = new AdvancedNode<char>();
d.RootNode.NextNode = new Node<char>();    // This will compile, 
                                           // but I don't want it to!

有什么方法可以在构建时强制Node.NextNode与此类型相同？我希望能够实现通用数据结构而无需进行转换.可能吗？我是否使用劣等设计模式？

解决方法:

一种可行的解决方案是使用“递归泛型”(请参见此post).

我们改变Node< T>的定义.到节点< N,T>其中N必须实现Node< N,T> …

abstract class Node<N, T>
    where N : Node<N, T>  // Here is the recursive definition
    where T : IComparable<T>
{
    T value;
    public N NextNode;

    public N GetLastNode()
    {
        N current = (N)this;
        while (this.NextNode != null)
        {
            current = current.NextNode;
        }
        return current;
    }

    // etc.
}

然后,您只需要更改AdvancedNode< T>的基类即可.到节点< AdvancedNode< T>,T>.

class AdvancedNode<T> : Node<AdvancedNode<T>, T>
    where T : IComparable<T>
{
    int Height;
    int Size;
    // etc.
}

以及对DataStructure< T,N>中的类型参数N的约束.到节点< N,T>.

class DataStructure<T, N>
    where T : IComparable<T>
    where N : Node<N, T>
{
    public N RootNode;

    // More code to follow, etc.
}

不幸的是,不可能使用“递归泛型”直接实例化一个类,因为它将需要编写如下内容：Node< Node< Node< ...,T&gt ;, T&gt ;, T>如果我们想要正确的类型.这就是为什么我使它抽象.为了有一个简单的节点,我创建了一个新类型：

class SimpleNode<T> : Node<SimpleNode<T>, T>
    where T : IComparable<T>
{
}