运行时将非泛型基类Node向下转为泛型派生类Node<T>的方案问询

现有代码实现 #

当前定义了非泛型基类Node和泛型派生类Node<T>，用于构建混合数据类型的链表：

public class Node{  
  public Node NextNode{get; set;}  
  public static Node<T> WithData<T>(T data) => new Node<T>(data);  
}  
public class Node<T>: Node{  
  public T Data{get; set;}  
  public Node(T data) => Data = data;  
}  

问题复现 #

使用时会遇到编译错误，因为NextNode被向上转型为Node基类，无法直接访问泛型子类的Data属性：

var node1 = Node.WithData(73);      // int类型节点  
var node2 = Node.WithData("Good luck!");    // string类型节点  
node1.NextNode = node2;         // 链接节点  
Notify(node1.Data == 73);  // 正常显示"true"  
Notify(node1.NextNode.GetType());       // 显示"Node`1[System.String]"  
Notify(node1.NextNode.Data == "Good luck!");  
// 编译错误：'Node' 不包含 'Data' 的定义  

报错原因是编译器仅能识别NextNode为Node类型，无法感知其实际运行时的泛型子类类型。

当前解决方案的弊端 #

现有几种 workaround 都存在明显问题：

• 强制向下转型：代码冗长，且编译时通常无法预知目标类型

  Notify(((Node<string>)node.NextNode).Data);  
  

• 使用dynamic：运行时性能损耗大

  Notify(((dynamic)node.NextNode).Data); 
  

• 类型判断链：维护性差，新增数据类型时需重复添加分支

  if(node.NextNode is Node<string> stringNode) Notify(stringNode.Data);  
  else if(node.NextNode is Node<int> intNode) Notify(intNode.Data);  
  // 更多else if分支...
  

核心问题 #

1. 是否有更合适的方法将Node向下转换为Node<T>（最好在运行时实现）？
2. 是否有更好的类设计方案，避免或自动完成这类向下转换？

解决方案 #

一、更优雅的运行时类型转换方法 #

可以通过泛型扩展方法结合模式匹配或反射实现通用转换，兼顾类型安全与灵活性：

public static class NodeExtensions
{
    // 强类型安全获取数据
    public static bool TryGetData<T>(this Node node, out T data)
    {
        if (node is Node<T> typedNode)
        {
            data = typedNode.Data;
            return true;
        }
        data = default;
        return false;
    }

    // 获取任意类型数据（返回object）
    public static object GetData(this Node node)
    {
        var nodeType = node.GetType();
        if (nodeType.IsGenericType && nodeType.GetGenericTypeDefinition() == typeof(Node<>))
        {
            var dataProperty = nodeType.GetProperty(nameof(Node<int>.Data));
            return dataProperty.GetValue(node);
        }
        throw new InvalidOperationException("当前节点无数据");
    }
}

使用示例：

// 强类型获取
if (node1.NextNode.TryGetData(out string strData))
{
    Notify(strData == "Good luck!");
}

// 任意类型数据获取
var data = node1.NextNode.GetData();
Notify(data.ToString());

这种方式既避免了硬编码类型分支，性能也优于dynamic，同时保留了类型安全特性。

二、优化类设计避免类型转换 #

方案1：引入非泛型数据接口

给基类添加IDataNode接口，暴露统一的Data访问入口，无需转型即可获取数据：

public interface IDataNode
{
    object Data { get; }
}

public class Node : IDataNode
{
    public Node NextNode { get; set; }
    public static Node<T> WithData<T>(T data) => new Node<T>(data);

    // 显式实现接口，避免基类暴露不必要的object属性
    object IDataNode.Data => throw new InvalidOperationException("非泛型节点无数据");
}

public class Node<T> : Node, IDataNode
{
    public T Data { get; set; }
    public Node(T data) => Data = data;

    // 实现接口，返回强类型数据的object形式
    object IDataNode.Data => Data;
}

使用时直接通过接口访问：

if (node1.NextNode is IDataNode dataNode)
{
    Notify(dataNode.Data.ToString() == "Good luck!");
}

方案2：使用访问者模式处理多类型节点

如果需要对不同类型的数据做差异化处理，访问者模式可以避免大量类型判断，符合开闭原则：

public interface INodeVisitor
{
    void Visit(Node<int> node);
    void Visit(Node<string> node);
    // 新增数据类型时添加对应方法
}

public class Node
{
    public Node NextNode { get; set; }
    public static Node<T> WithData<T>(T data) => new Node<T>(data);
    public virtual void Accept(INodeVisitor visitor) { }
}

public class Node<T> : Node
{
    public T Data { get; set; }
    public Node(T data) => Data = data;

    public override void Accept(INodeVisitor visitor)
    {
        // 通过模式匹配调用对应类型的访问方法
        if (visitor is INodeVisitor<T> typedVisitor)
        {
            typedVisitor.Visit(this);
        }
    }
}

// 泛型访问者接口，简化新增类型的实现
public interface INodeVisitor<T> : INodeVisitor
{
    void Visit(Node<T> node);
}

// 示例访问者：打印节点数据
public class PrintVisitor : INodeVisitor<int>, INodeVisitor<string>
{
    public void Visit(Node<int> node) => Notify(node.Data.ToString());
    public void Visit(Node<string> node) => Notify(node.Data);
}

使用方式：

var visitor = new PrintVisitor();
node1.Accept(visitor);
node1.NextNode.Accept(visitor);

新增数据类型时，只需实现对应的访问者方法即可，无需修改原有逻辑。

方案3：封装泛型链表容器

设计一个链表管理类，内部处理节点类型转换，对外提供简洁的操作接口：

public class LinkedList
{
    private Node _head;

    public void Add<T>(T data)
    {
        var newNode = Node.WithData(data);
        if (_head == null)
        {
            _head = newNode;
        }
        else
        {
            var current = _head;
            while (current.NextNode != null)
            {
                current = current.NextNode;
            }
            current.NextNode = newNode;
        }
    }

    // 遍历所有节点数据
    public void ForEach(Action<object> action)
    {
        var current = _head;
        while (current != null)
        {
            if (current is IDataNode dataNode)
            {
                action(dataNode.Data);
            }
            current = current.NextNode;
        }
    }

    // 强类型遍历指定类型节点
    public void ForEach<T>(Action<T> action)
    {
        var current = _head;
        while (current != null)
        {
            if (current.TryGetData(out T data))
            {
                action(data);
            }
            current = current.NextNode;
        }
    }
}

使用示例：

var list = new LinkedList();
list.Add(73);
list.Add("Good luck!");
list.ForEach(data => Notify(data.ToString()));
list.ForEach<string>(str => Notify(str == "Good luck!"));

内容的提问来源于stack exchange，提问作者SharpAttempt