解释器模式 - 设计模式学习

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

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

　　下面给出解释器模式的结构图：

　　　　

　　下面给出解释器模式的基本代码结构：

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

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

    //NonterminalExpression(非终结表达式)，为文法中的非终结符实现解释操作。对文法中每一条规则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; }
        }
    }
 
    class Program
    {
        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.ReadKey();
        }
    }  
}

　　结果如下所示：

　　　　

　　解释器模式的好处：

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

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

　　解释器模式的不足：

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

　　下面回到《大话设计模式》里面的音乐解释器的实现。

　　

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

    //表达式类
    abstract class Expression
    { 
        //解释器
        public void Interpret(PlayContext context)  //此方法用于将当前的演奏文本第一条命令获得命令字母和其参数值，
        //如O3E0.3，则playKey为O而playValue为3
        {
            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);   //获得playKey和playValue后将其从演奏文本中移除
                                                                                                    //如 O 3 E 0.5 G 0.5 变为 E 0.5 G 0.5
                Excute(playKey, playValue);     //抽象方法"执行"，不同的文法子类，有不同的执行处理
            }
            
        }

        //执行
        public abstract void Excute(string key, double value);
    }

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

    //音阶类
    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.Write("{0} ",scale);
        }
    }


    class Program
    {
        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 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();   //当首字段为O时，则表达式实例化为音阶
                            break;
                        case "C":
                        case "D":
                        case "E":
                        case "F":
                        case "G":
                        case "A":
                        case "B":
                        case "P":                       //当首字母是CDEFGAB,以及休止符P时，则实例化为音符
                            expression = new Note();
                            break;
                    }
                    expression.Interpret(context);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }
    }  
}

　　结果如下图所示: