设计模式（二十三）解释器模式

解释器模式（interpreter），给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语句中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

应用场景：当有一个语言需要解释执行，并且你可将该语言中的一个句子表示为一个抽象语法树时，可使用解释器模式。如：正则表达式、浏览器等应用。

优点：解释器模式可以很容易地改变和扩展文法，因为该模式使用类来表示文法规则，你可使用继承来改变或扩展该文法，也比较容易实现文法，因为定义抽象语法树中各个节点的类的实现大体类似，这些类都易于直接编写。

不足：解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。建议当文法非常复杂时，使用其他的技术如语法分析程序或编译生成器来处理。

基本代码

// 抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享
abstract class AbstractExpression
{
  public abstract void Interpret(Context context);
}

// 终结符表达式，实现与文法中的终结符相关联的解释操作。实现抽象表达式中所要求的接口，
// 主要是一个 Interpret() 方法。文法中每一个终结符都有一个具体终结表达式与之相对应。 
class TerminalExpression : AbstractExpression
{
  public override void Interpret(Context context)
  {
    Console.WriteLine("终端解释器");
  }
}

// 非终结符表达式，为文法中的非终结符实现解释操作。对文法中的每一条规则R1、R2...Rn 都需要一个具体的非终结符表达式类。
// 通过实现抽象表达式的 Interpret() 方法实现解释器操作。解释操作以递归方式调用上面所提到的代表 R1、R2...Rn 中各个符号的实例变量
class NonterminalExpression : AbstractExpression
{
  public override void Interpret(Context context)
  {
    Console.WriteLine("非终端解释器");
  }
}

//  Context 包含解释器之外的一些全局信息
class Context
{
  private string input;
  public string Input
  {
    get { return input; }
    set { input = value; }
  }

  private string output;
  public string Output
  {
    get { return output; }
    set { output = value; }
  }
}

// 客户端构建表示该文法定义的语言中一个特定的句子的抽象语法树。
// 调用解释操作
static void Main(string[] args)
{
  Context context = new Context();

  IList<AbstractExpression> list = new List<AbstractExpression>();
  list.Add(new TerminalExpression());
  list.Add(new NonterminalExpression());
  list.Add(new TerminalExpression());
  list.Add(new TerminalExpression());

  foreach(AbstractExpression exp in list)
  {
    exp.Interpret(context);
  }

  Console.Read();
}

【例】

基本代码 

// 演奏内容
class PlayContext
{
  // 演奏文本
  private string text;
  public string PlayText
  {
    get { return text; }
    set { text = value; }
  }
}

// 抽象表达式
abstract class Expression
{
  // 解释器
  public void Interpret(PlayContext context);
  {
    if(context.PlayText.Length == 0)  return;
    else
    {
      string playKey = context.PlayText.Substring(0, 1);
      context.PlayText = context.PlayText.Substring(2);
      double playValue = Convert.ToDouble(context.PlayText.Substring(0, context.PlayText.IndexOf(" ")));
      context.PlayText = context.PlayText.Substring(context.PlayText.IndexOf(" ") + 1);

      Excute(playKey, playValue);
    }
  }

  // 执行，不同的文法子类，有不同的执行处理
  public abstract void Excute(string key, double value);
}

// 音符类
class Note : Expression
{
  public override void Excute(string key, double value)
  {
    string note = "";
    switch(key)
    {
      case "C":
        note = "1";
        break;
      case "D":
        note = "2";
        break;
      case "E":
        note = "3";
        break;
      case "F":
        note = "4";
        break;
      case "G":
        note = "5";
        break;
      case "A":
        note = "6";
        break;
      case "B":
        note = "7";
        break;
    }
    Console.WriteLine("{0}", note);
  }
}

// 音符类
class Scale : Expression
{
  public override void Excute(string key, double value)
  {
    string scale = "";
    switch(Convert.ToInt32(value))
    {
      case 1:
        scale = "低音";
        break;
      case 2:
        scale = "中音";
        break;
      case 3:
        scale = "高音";
        break;
    }
    Console.WriteLine("{0}", scale);
  }
}

// 客户端
static void Main(string[] args)
{
  PlayContext context = new PlayContext();
  Console.WriteLine("上海滩：");
  context.Playtext = "O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 G 1 C 0.5 E 0.5 D 3";
  Expression expression = null;
  try
  {
    while(context.PlayText.Length > 0)
    {
      string str = context.PlayText.Substring(0, 1);
      switch(str)
      {
        case "O":
          expression = new Scale();
          break;
        case "C":
        case "D":
        case "E":
        case "F":
        case "G":
        case "A":
        case "B":
        case "P":
          expression = new Note();
          break;
      }
      expression.Interpret(context);
    }
  }
  catch(Exception ex)
  {
    Console.WriteLine(ex.Message);
  }
  Console.Read();
}