与类实例具有相同类型的成员

Question

正如标题所说，我想知道是否可能。

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

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 与this 的类型相同？我希望能够实现通用数据结构而无需进行强制转换。是否可以？我使用的是劣质设计模式吗？

Answer 1

一种可行的解决方案是使用“递归泛型”（参见post）。

我们将Node<T> 的定义更改为Node<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> 的基类更改为Node<AdvancedNode<T>, T>。

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

以及DataStructure<T, N>到Node<N, T>中对类型参数N的约束。

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>, T>, T>。这就是我把它抽象的原因。为了有一个简单的节点，我创建了一个新类型：

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

Answer 2

我没有 VS，但在我看来你应该：

1. 将Node<T> 更改为Node<TData,TNode> 并将NextNode 声明为Node<TData,TNode>。
2. 将AdvancedNode 声明为AdvancedNode<TData> : Node<TData,AdvancedNode<TData>>。

这将确保子节点与根节点的类型相同。为所有其他节点类型复制 2)。

1. 将RootNode 属性移动到Node（它似乎比数据更重要）。
2. 将DataStructure<T,N> 更改为DataStructure<TNode>（如果需要，从TNode 推断TData）

这将使代码更简洁（在关注点分离方面）并且更易于理解，并且可以帮助您消除 DataStructure 依赖于节点类型的需要，这将有助于简化事情。让这两种泛型类型相互交叉依赖并不是一个好的设计，所以如果可能的话，我的目标是消除这种情况。

Answer 3

根据您的代码，唯一知道N 的类是DataStructure<T, N>。在下面的阐述中，我使用TValue 代替T，并使用TNode 代替N。

你的期望是：

1. 约束传递给DataStructure<TValue, TNode>的节点类型；这样一个节点的NextNode 也属于同一类型。

2. 无需额外转换

那么我能想到的最好的事情就是让节点类型成为一个嵌套的泛型类，你仍然可以约束它的类型参数。

由于IComparable<T>只是值的约束，与你的问题无关，我在下面的代码中把它去掉，使代码更清晰易懂，如果你需要的话，把它加回来。

• 代码

  public partial class DataStructure<TValue, TNode>
          where TNode: DataStructure<TValue, TNode>.Node<TValue> {
      public partial class Node<T> {
          public TNode GetLastNode() {
              var current=this as TNode;
  
              for(; null!=current.NextNode; current=current.NextNode)
                  ;
  
              return current;
          }
  
          public TNode NextNode {
              set;
              get;
          }
  
          public TValue value {
              private set;
              get;
          }
      }
  
      public TNode RootNode;
  }
  
  public partial class AdvancedNode<TValue>
          : DataStructure<TValue, AdvancedNode<TValue>>.Node<TValue> {
      int Height;
      int Size;
  }
  

注意原始代码while(this.NextNode!=null) { current=current.NextNode; } 中的while 循环表达式会导致NullReferenceException。

通过上面的代码，现在您可以使用以下测试方法进行测试，该测试方法是原始版本的修改版本：

public static partial class TestClass {
    public static void TestMethod() {
        DataStructure<char, AdvancedNode<char>> d=
            new DataStructure<char, AdvancedNode<char>>();

        d.RootNode=new AdvancedNode<char>();
        d.RootNode.NextNode=new AdvancedNode<char>();

        // type NO error! Will compile
        AdvancedNode<char> y=d.RootNode.NextNode;

        var rootNode=d.RootNode;
        var lastNode=rootNode.GetLastNode();
        Console.WriteLine("Is y the last node? "+(lastNode==y));
        Console.WriteLine("Is rootNode the last node? "+(lastNode==rootNode));
    }
}

由于Node<T>是引用类型，==是用来比较引用的，结果符合预期。

您可以对稍后要声明的其他类执行相同的操作。

就个人而言，我会考虑使用@987654321@ 而不是自己实现它。你在问，所以有答案。

Answer 4

另一种选择可能是指定一个组合来反对使用继承。这样做的缺点是扩展特定组合会更加困难。

例如，使用问题中的类：

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

    // More code to follow, etc.
}

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

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

    // etc.
}

class AdvancedNodeData {
    int Height;
    int Size;
    // etc.
}

DataStructure<char, AdvancedNodeData> d = new DataStructure<char, AdvancedNodeData>();
d.RootNode = new Node<char, AdvancedNodeData>();
d.RootNode.NextNode = new Node<char, AdvancedNodeData>();
Node<char, AdvancedNodeData> y = d.RootNode.NextNode;