解释器模式

简介：

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

        对于一些固定文法构建一个解释句子的解释器。文法可以理解为可以提炼出逻辑的数据。例如R = R1 + R2，常规的理解是整数相加，但可以给定特殊的含义，这就可用到解释器模式，类似重写“+=”、“-+”等。

 

介绍：

解释器模式结构

 

特征

优点	1.提供了新的解释表达式的方式。 2.易于实现简单文法。
缺点	1.利用场景较少。 2.复杂的文法难维护。
特点	1.给文法一个特定的解释。

角色

抽象表达式(AbstractExpression)	定义解释器的接口。
终结符表达式(Terminal Expression)	实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。
非终结符表达式(Nonterminal Expression)	实现了抽象表达式角色所要求的接口，文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+”就是非终结符，解析“+”的解释器就是一个非终结符表达式。
环境角色(Context)	存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。可使用HashTable存放。

 

使用： 

本案例是解释了“||”和“&&”。

    //AbstractExpression
    public interface Expression
    {
        bool interpret(string context);
    }

    //Terminal Expression
    public class TerminalExpression : Expression
    {
        private string data;

        public TerminalExpression(string data)
        {
            this.data = data;
        }

        public bool interpret(string context)
        {
            if (context.Contains(data))
            {
                return true;
            }
            return false;
        }
    }

    //Nonterminal Expression
    public class OrExpression : Expression
    {
        private Expression expr1 = null;
        private Expression expr2 = null;

        public OrExpression(Expression expr1, Expression expr2)
        {
            this.expr1 = expr1;
            this.expr2 = expr2;
        }

        public bool interpret(string context)
        {
            return expr1.interpret(context) || expr2.interpret(context);
        }
    }

    //Nonterminal Expression
    public class AndExpression : Expression
    {
        private Expression expr1 = null;
        private Expression expr2 = null;

        public AndExpression(Expression expr1, Expression expr2)
        {
            this.expr1 = expr1;
            this.expr2 = expr2;
        }

        public bool interpret(string context)
        {
            return expr1.interpret(context) && expr2.interpret(context);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {        
            //解释器模式调用
            Expression Jordon = new TerminalExpression("Jordon");
            Expression YaoMing = new TerminalExpression("YaoMing");
            Expression Retirement = new TerminalExpression("Retirement");

            Expression male = new OrExpression(Jordon, YaoMing);
            Expression retirement = new AndExpression(Jordon, Retirement);

            bool isMale = male.interpret("Jordon");
            bool isRetirement = retirement.interpret("Jordon Retirement");
        }
   }