解释器模式

定义

建立一个解释器解释程序的逻辑与业务。也就是将一个比较复杂的业务分解成语法树或者是逻辑树。

类图

代码

/// <summary>
    /// 抽象表达式
    /// </summary>
    public abstract class Expression
    {
        public abstract int Interprete(Dictionary<string, int> dicParameters);
    }
    /// <summary>
    /// 变量表达式（变量）
    /// </summary>
    public class VarExpress : Expression
    {
        private string key;
        public VarExpress(string key)
        {
            this.key = key;
        }
        public override int Interprete(Dictionary<string, int> dicParameters)
        {
            if (dicParameters.ContainsKey(key))
            {
                return dicParameters[key];
            }
            else
            {
                throw new Exception(string.Format("{0} is not avaliable", key));
            }
        }
    }
    /// <summary>
    /// 计算符号表达式
    /// </summary>
    public abstract class SymbolExpress : Expression
    {
        protected Expression leftExpression;
        protected Expression rightExpression;
        public SymbolExpress(Expression left, Expression right)
        {
            leftExpression = left;
            rightExpression = right;
        }
    }
    /// <summary>
    /// 加法表达式
    /// </summary>
    public class AddExpress : SymbolExpress
    {
        public AddExpress(Expression left, Expression right) : base(left, right)
        {

        }
        public override int Interprete(Dictionary<string, int> dicParameters)
        {
            return leftExpression.Interprete(dicParameters) + rightExpression.Interprete(dicParameters);
        }
    }
    /// <summary>
    /// 减法表达式
    /// </summary>
    public class SubExpress : SymbolExpress
    {
        public SubExpress(Expression left, Expression right) : base(left, right)
        {

        }
        public override int Interprete(Dictionary<string, int> dicParameters)
        {
            return leftExpression.Interprete(dicParameters) - rightExpression.Interprete(dicParameters);
        }
    }
    /// <summary>
    /// 计算器
    /// </summary>
    public class Calculator
    {
        private Expression expression;   //表达式

        public Calculator(String expressionString)
        {
            Stack<Expression> stack = new Stack<Expression>();

            char[] charArray = expressionString.ToCharArray();

            Expression left = null;

            Expression right = null;

            for (int i = 0; i < charArray.Length; i++)
            {

                switch (charArray[i])
                {

                    case '+': //加法

                        //加法结果放到堆栈中

                        left = stack.Pop();

                        right = new VarExpress((charArray[++i]).ToString());

                        stack.Push(new AddExpress(left, right));

                        break;

                    case '-':

                        left = stack.Pop();

                        right = new VarExpress((charArray[++i]).ToString());

                        stack.Push(new SubExpress(left, right));

                        break;
                    //当然还有乘法/除法等
                    default: //默认就是变量
                        stack.Push(new VarExpress((charArray[i]).ToString()));
                        break;

                }

            }
            this.expression = stack.Pop();

        }

        /// <summary>
        /// 计算
        /// </summary>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public int Run(Dictionary<String, int> parameters)
        {
            return this.expression.Interprete(parameters);

        }

    }

调用部分

 class Program
    {
        static void Main(string[] args)
        {
            Calculator c = new Calculator("a+b-c");
            Dictionary<string, int> dic = new Dictionary<string, int>();
            dic.Add("a", 100);
            dic.Add("b", 10);
            dic.Add("c", 20);
            int result = c.Run(dic);
            Console.WriteLine(result.ToString());
            Console.ReadLine();
        }
    }

总结

计算表达式就是一个非常经典的解释器模式的体现。当然像语法的解析、表达式的解析等引入解释器模式大大方便了实现与理解。像例子中的加减运算的实现，通过定义加减运算表达式和变量表达式，再通过栈的临时存储，很好的实现了通过解释给出的表达式，而实现计算的效果。当然当看到变量表达式是叶子节点，而运算表达式却相当于枝节点，怎么跟组合表达式有些类似呢？最终还是回到设计模式的关键点，还是他们关注点不一样，组合在于包含组成，他的组成方式可能是集合，而且它更多的体现的包含关系。而解释器在于解释，是一种行为。通过自身内部的迭代解释得出最终的运算，并得出结果。

其实，解释器用得还是比较少的，感觉蛮高大上的。