如何使用节点？

Question

我正在构建一棵树来解析一些文本，因此我创建了一些节点：

abstract class Node { }

class TextNode : Node
{
    public readonly string Text;
    public TextNode(string text)
    {
        Text = text;
    }
    public TextNode(char ch)
    {
        Text = ch.ToString();
    }
}

class VariableNode : Node
{
    public readonly string Name;
    public VariableNode(string name)
    {
        Name = name;
    }
}

我将很快添加一些“分支”节点（包含其他节点的节点）。

我想知道处理它们的最佳方法。现在我有一些代码看起来像这样：

foreach (var item in nodes)
{
    if (item is TextNode)
        sb.Append(((TextNode)item).Text);
    if (item is VariableNode)
        sb.Append(dict[((VariableNode)item).Name]);
}

这看起来有点笨拙，并且随着我添加它只会变得更糟。

我是否应该

1. 尝试以某种方式将逻辑封装到基 Node 类中，以便我可以只使用 DoStuff() 函数而不必担心类型转换？
2. 我是否应该为每个节点类型添加某种枚举，以便我可以使用 switch 而不是 foreach 循环？
3. 还有别的事吗？

---

需要给你们提供更多背景信息。在上面的示例中，变量节点需要访问字典才能呈现自身。

我正在解析一个模板。在模板中，有变量。变量名称及其值存储在字典中。在解析时，我没有值（好吧，我可以，但我希望能够使用不同的值重新渲染模板），所以我需要能够将不同的字典传递给模板。按照我设置的方式，模板执行所有渲染，节点不执行任何操作。我想我可以将字典再传递一个级别到每个节点，以便它们可以渲染自己......

---

为了详细说明#1，

// in class Template
public string Render(Dictionary<string, object> dict)
{
    var sb = new StringBuilder();

    foreach (var item in nodes)
        sb.Append(item.Render(dict));

    return sb.ToString();
}

interface INode {
    string Render(Dictionary<string, object> dict);
}

class TextNode : INode
{
    private string _text;

    public TextNode(string text)
    {
        _text = text;
    }
    public TextNode(char ch)
    {
        _text = ch.ToString();
    }

    public string Render(Dictionary<string, object> dict)
    {
        return _text;
    }
}

class VariableNode : INode
{
    private string _name;

    // TODO: filters...

    public VariableNode(string name)
    {
        _name = name;
    }

    public string Render(Dictionary<string, object> dict)
    {
        return dict[_name].ToString();
    }
}

我想这也不是一个糟糕的解决方案。

---

到目前为止的解决方案：

1. 使用枚举和 switch
2. 构建类型/操作的字典，使 switch 更清晰
3. 多态性 (x2)
4. 访问者模式（还没读过这篇文章）
5. 使用ANTLR——尽管 ANTLR 会构建一棵树，然后这个问题再次出现

Answer 1

您可以改为使用接口并定义enum属性，例如。 NodeType Type，其中 Type 是一个 enum，其值为 TextNode、VariableNode。不过，这里您还需要转换节点才能获取值。您可以尝试添加一个名为 Value 的属性，该属性根据 NodeType 返回 Text 或 Name。如果可以从 VariableNode 访问 dict，则 Value 可以返回您的方法所需的确切值。

总而言之，我认为接口比抽象类更适合您的需求。

Answer 2

如果您将拥有许多具有不同行为的不同节点类型，我当然会考虑使用基类 Node，然后为实现特定行为的每种类型实现一个专门的节点类。

将树处理逻辑放入节点的另一种方法是使用访问者模式。在这种情况下，您往往会拥有更同质的树结构，并在树外部维护特定的处理规则。

如果这棵树是为了解析文本的目的，你看过 Antlr 吗？该工具可以根据指定的语法为您生成语法树。

Answer 3

将 foreach(var item in Nodes) 移动到抽象节点类中的方法（即 BuildAll）中，创建一个抽象/虚拟方法 Build（在抽象 Node 类中）并调用 BuildAll 中的方法 Build() 并让它输出一个字符串...

像这样：

    public abstract string Build();

    public string BuildAll() {
      var output = new StringBuilder();
      foreach(var node in nodes) {
        output.append(node.Build()); 
      }
      return output.toString();
    }

并在节点的每个实际实现中覆盖它...
所以 TextNode 将有...

public override string Build() {
  return ... extract whatever you want from TextNode;
}

在这种情况下，您的基类不需要知道其后代的确切实现，因此不会违反开闭原则。

Answer 4

您可以创建一个 Dictionary> - 键是节点类型和 Action 委托 是您对每个委托执行的操作。

您可以简单地执行以下操作：

Dictionary[typeof(variable)];

以便为每种类型执行正确的操作。

Answer 5

多态性正是您想要的。像这样的：

class Node
{
   public virtual string ToDisplayText(params object[] parameters)
   {
      return string.Empty;
   }
}
class TextNode : Node
{
   public override string ToDisplayText(params object[] parameters)
   {
      return this.Text;
   }
}
class VariableNode : Node
{
   public override string ToDisplayText(params object[] parameters)
   {
      //check parameters
      var dict = (Dictionary<string,string>)parameters[0];
      return dict[this.Name];
   }
}

所以你可以：

foreach(var node in nodes)
{
   sb.Append(node.ToDisplayText(dict));
}