设计模式笔记 15. Interpreter 解释器模式(行为型模式)

 

15. Interpreter 解释器模式      2008-09-07

动机(Motivation)：

在软件构建过程中，如果某一特定领域的问题比较复杂，类似的结构不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。

在这种情况下，将特定领域的问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。

意图(Intent)：

给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。           ——《设计模式》GoF 

基本代码：  

    //包含解释器之外的一些全局信息
    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; }
        }
    }

 

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

 

    //终结符表达式，实现与文法中的终结符相关联的解释操作
    class TerminalExpression : AbstractExpression
    {
        public override void Interpret(Context context)
        {
            Console.WriteLine("终端解释器");
        }
    }

 

    //非终结符表达式，为文法中的非终结符实现解释操作，对文法中的每一条规则
    //R1，R2.Rn都需要定义一个具体的非终结符表达式类
    class NonterminalExpression : AbstractExpression
    {
        public override void Interpret(Context context)
        {
            Console.WriteLine("非终端解释器");
        }
    }

 

Interpreter 的几个要点：

Interpreter模式的应用场合是Interpreter模式应用中的难点，只有满足“业务规则频繁变化，且类似的结构不断重复出现，并且容易抽象为语法规则的问题”才适合使用Interpreter模式。

使用Interpreter模式来表示文法规则，从而可以使用面向对象技巧来方便地“扩展”文法。

Interpreter模式比较适合简单的文法表示，对于复杂的文法表示，Interpreter模式会产生比较大的类层次结构，需要求助于语法分析生成器这样的标准工具。

适用性

1．需要类似命令行界面的人机交互：虽然图形界面占统治地位，但仍有些场合需要类似命令行的人机交互。如：查询检索等应用，输入检索表达式要更有效率。

2．用表达式表示逻辑或数学运算：如在统计软件中，某些指标间的关系用表达式比某一种数据结构表示要简洁方便的多。

3．定制输出：如用户需要保存查询的结果。（？？？）

 

例子：（以李建忠老师《C#设计模式纵横谈》举的例子为例，将中文的数字转换成数学数字）

Context类：包含解释器之外的一些全局信息

    //上下文
    class Context
    {
        private string statement;

        private int data;

        public Context(string statement)
        {
            this.statement = statement;
        }

        public string Statement
        {
            get
            {
                return statement;
            }
            set
            {
                statement = value;
            }
        }

        public int Data
        {
            get
            {
                return data;
            }
            set
            {
                data = value;
            }
        }
    }

 

抽象的Expression类：抽象表达式，声明了一个抽象的解释操作，这个接口为抽象语法树中的所有节点所共享

    abstract class Expression
    {
        protected Dictionary<string, int> table = new Dictionary<string, int>(9);

        public Expression()
        {
            table.Add("一", 1);
            table.Add("二", 2);
            table.Add("三", 3);
            table.Add("四", 4);
            table.Add("五", 5);
            table.Add("六", 6);
            table.Add("七", 7);
            table.Add("八", 8);
            table.Add("九", 9);
        }

        public abstract string GetPostfix();

        public abstract int Multiplier();

        public virtual int GetLength()
        {
            return this.GetPostfix().Length + 1;
        }

        public virtual void Interpreter(Context context)
        {
            if (context.Statement.Length == 0)
            {
                return;
            }

            foreach (string key in table.Keys)
            {
                int value = table[key];
                if (context.Statement.EndsWith(key + GetPostfix()))
                {
                    context.Data += value * this.Multiplier();
                    context.Statement = context.Statement.Substring(0, context.Statement.Length - this.GetLength());
                }
            }

            if (context.Statement.EndsWith("零"))
            {
                context.Statement = context.Statement.Substring(0, context.Statement.Length - 1);
            }
        }
    }

 

TerminalExpression：终结符表达式，实现与文法中的终结符相关联的解释操作

    class GeExpression : Expression
    {
        public override string GetPostfix()
        {
            return "";
        }

        public override int Multiplier()
        {
            return 1;
        }
    }

    class ShiExpression : Expression
    {
        public override string GetPostfix()
        {
            return "十";
        }

        public override int Multiplier()
        {
            return 10;
        }
    }

    class BaiExpression : Expression
    {
        public override string GetPostfix()
        {
            return "百";
        }

        public override int Multiplier()
        {
            return 100;
        }
    }

    class QianExpression : Expression
    {
        public override string GetPostfix()
        {
            return "千";
        }

        public override int Multiplier()
        {
            return 1000;
        }
    }

 

NonterminalExpression：非终结符表达式，为文法中的非终结符实现解释操作

    class WanExpression : Expression
    {
        public override string GetPostfix()
        {
            return "万";
        }

        public override int Multiplier()
        {
            return 10000;
        }

        public override void Interpreter(Context context)
        {
            if (context.Statement.Length == 0)
            {
                return;
            }

            ArrayList tree = new ArrayList();
            tree.Add(new GeExpression());
            tree.Add(new ShiExpression());
            tree.Add(new BaiExpression());
            tree.Add(new QianExpression());
            foreach (string key in table.Keys)
            {
                if (context.Statement.EndsWith(this.GetPostfix()))
                {
                    int temp = context.Data;
                    context.Data = 0;
                    context.Statement = context.Statement.Substring(0, context.Statement.Length - 1);

                    foreach (Expression exp in tree)
                    {
                        exp.Interpreter(context);
                    }

                    context.Data = temp + this.Multiplier() * context.Data;
                }
            }
        }
    }

 

客户端代码：

    class Program
    {       
        static void Main(string[] args)
        {
            string roman = "一千零五万六千零七十二";
            Context context = new Context(roman);

            ArrayList tree = new ArrayList();
            tree.Add(new GeExpression());
            tree.Add(new ShiExpression());
            tree.Add(new BaiExpression());
            tree.Add(new QianExpression());
            tree.Add(new WanExpression());

            foreach (Expression exp in tree)
            {
                exp.Interpreter(context);
            }

            Console.WriteLine("{0} = {1}", roman, context.Data);

            Console.Read();
        }
    }

 

运行结果：一千零五万六千零七十二 = 10056072

如果要对功能进行扩展，把数字继续增大至亿，只需再增加一个YiExpression类，继承于Expression类，并重写类中的解释器就够了。。。