解释器模式(interpreter)

简介

解释器模式，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。解释器模式提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

书中实例

今天小菜被老板交出外面，没想到老板好好的夸奖了小菜一番，小菜以此和大鸟炫耀，大鸟说你还年轻，老板的意思是最近可能工作会多些，保持住年轻人。小菜连说，我身边要是有个解释器就好了，这弦外之音可真难懂。大鸟说，别急啊，今天我们就来学解释器模式，我们先以音乐播放器为例吧。

解释器模式实现程序

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

    //表达式类
    abstract class AbstractExpression
    {
        //解释器
        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 : AbstractExpression
    {
        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 : AbstractExpression
    {
        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);
        }
    }

    //音速类
    class Speed : AbstractExpression
    {
        public override void Excute(string key, double value)
        {
            string speed;
            if (value < 500)
                speed = "快速";
            else if (value >= 1000)
                speed = "慢速";
            else
                speed = "中速";

            Console.Write("{0} ", speed);
        }
    }

    //客户端
    class Program
    {
        static void Main(string[] args)
        {
            PlayContext context = new PlayContext();
            //音乐-上海滩
            Console.WriteLine("上海滩：");
            context.PlayText = "T 500 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 E 0.5 D 3 ";
            AbstractExpression expression = null;
            try
            {
                while (context.PlayText.Length > 0)
                {
                    string str = context.PlayText.Substring(0, 1);
                    switch (str)
                    {
                        case "O":
                            expression = new Scale();
                            break;
                        case "T":
                            expression = new Speed();
                            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();
        }
    }

组成类图

关系介绍

抽象表达式(AbstractExpression)是终结符表达式(TerminalExpression)和非终结符表达式(NonterminalExpression)的父类，非终结符表达式和抽象表达式之间还有聚合关系，抽象表达式拥有非终结符表达式。

解释器模式的构成

AbstractExpression(抽象表达式):声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享

TerminalExpression(终结符表达式):实现与文法中的终结符相关联的解释操作。实现抽象表达式中所要求的接口，主要是一个interpret()方法。文法中每一个终结符都有一个具体终结表达式与之相对应。

NonterminalExpression(非终结符表达式):为文法中的非终结符实现解释操作。对文法中每一条规则都需要一个具体的非终结符表达式类。通过实现抽象表达式的interpret()方法实现解释操作。

解释器模式的优缺点

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

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

使用场景

1.通常当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。