铭轩同学

铭轩,为自己代言!

  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理

  解释器模式(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();
        }
    }  
}
复制代码

  结果如下图所示:

    

 
 
分类: 设计模式
 
0
0
 
(请您对文章做出评价)
 
« 上一篇:享元模式 - 设计模式学习
» 下一篇:访问者模式 - 设计模式学习
posted on 2015-09-02 11:48  铭轩同学  阅读(311)  评论(0编辑  收藏  举报