C#中如何让InnerNode的子节点可指向InnerNode或OuterNode？

你当前的问题核心是：用基类Node统一子节点引用后，无法直接访问子类的专属成员，而维护多组类型变量又会增加逻辑复杂度。以下是几种实用的解决方案：

方案一：使用is/as运算符进行类型转换 #

这是最直接的方案，适合刚接触C#的开发者，不需要修改现有节点类的核心结构，只需要在遍历/处理节点时做类型判断和转换。

首先保留你最初的基类结构（建议把InnerNode的子节点成员改为公开或添加getter，方便外部访问）：

public abstract class Node {
    public Node parent;
}
public class InnerNode : Node {
    public Node leftChild, rightChild; // 改为public或添加访问器
    public int someInnerNodeMember;
}
public class OuterNode : Node {
    public float someOuterNodeMember;
}

然后在遍历或处理节点时，用is运算符判断类型并直接赋值，避免重复转换：

void TraverseTree(Node currentNode)
{
    if (currentNode is InnerNode innerNode)
    {
        // 访问InnerNode的专属成员
        Console.WriteLine($"Inner节点专属值：{innerNode.someInnerNodeMember}");
        // 递归遍历子节点
        if (innerNode.leftChild != null) TraverseTree(innerNode.leftChild);
        if (innerNode.rightChild != null) TraverseTree(innerNode.rightChild);
    }
    else if (currentNode is OuterNode outerNode)
    {
        // 访问OuterNode的专属成员
        Console.WriteLine($"Outer节点专属值：{outerNode.someOuterNodeMember}");
    }
}

说明 #

• is运算符会先判断对象类型，匹配成功时直接将对象转换为目标类型并赋值给变量，比传统的as+null判断更简洁。
• 这种方式只在需要访问专属成员时才做类型转换，不需要维护多组子节点变量，逻辑更清晰。

方案二：使用访问者模式（Visitor Pattern） #

如果你的树形结构后续需要添加多种操作逻辑（比如遍历、计算、序列化等），访问者模式可以将操作逻辑与节点类分离，符合开闭原则。

步骤1：定义访问者接口和节点基类的Accept方法 #

// 访问者接口：定义对每种节点的操作
public interface INodeVisitor
{
    void VisitInnerNode(InnerNode node);
    void VisitOuterNode(OuterNode node);
}

public abstract class Node
{
    public Node parent;
    // 接受访问者，让访问者处理当前节点
    public abstract void Accept(INodeVisitor visitor);
}

步骤2：实现具体节点类的Accept方法 #

public class InnerNode : Node
{
    public Node leftChild, rightChild;
    public int someInnerNodeMember;

    public override void Accept(INodeVisitor visitor)
    {
        // 让访问者处理当前InnerNode
        visitor.VisitInnerNode(this);
    }
}

public class OuterNode : Node
{
    public float someOuterNodeMember;

    public override void Accept(INodeVisitor visitor)
    {
        // 让访问者处理当前OuterNode
        visitor.VisitOuterNode(this);
    }
}

步骤3：实现具体的访问者（比如遍历逻辑） #

public class TreeTraverser : INodeVisitor
{
    public void VisitInnerNode(InnerNode node)
    {
        Console.WriteLine($"Inner节点专属值：{node.someInnerNodeMember}");
        // 递归处理子节点
        node.leftChild?.Accept(this);
        node.rightChild?.Accept(this);
    }

    public void VisitOuterNode(OuterNode node)
    {
        Console.WriteLine($"Outer节点专属值：{node.someOuterNodeMember}");
    }
}

使用方式 #

// 构建树示例
var root = new InnerNode { someInnerNodeMember = 10 };
root.leftChild = new OuterNode { someOuterNodeMember = 3.14f };
root.rightChild = new InnerNode { someInnerNodeMember = 20 };

// 执行遍历
var traverser = new TreeTraverser();
root.Accept(traverser);

说明 #

• 后续新增操作时，只需要添加新的INodeVisitor实现类，不需要修改任何节点类的代码。
• 这种方式适合节点类型固定、操作逻辑较多的场景，代码结构更清晰。

方案三：使用switch表达式简化类型判断 #

C# 8.0及以上支持switch表达式，可以更简洁地处理多类型分支：

string GetNodeInfo(Node node)
{
    return node switch
    {
        InnerNode i => $"Inner节点：{i.someInnerNodeMember}",
        OuterNode o => $"Outer节点：{o.someOuterNodeMember}",
        _ => "未知节点类型"
    };
}

可以和遍历逻辑结合使用，让代码更简洁。

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