行为型设计模式——解释器模式

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

适用于

Interpreter模式适用于当有一个语言需要解释执行，并且可将该语言中的句子表示为一个抽象语法树时，以下情况效果最好：

①该文法简单。对于复杂的发文，文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。它们无须构建抽象语法树即可解释表达式，这样可以节省空间还可能节省时间。

②效率不是一个关键问题。最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将它们转换成另一种形式。不过，即使在这种情况下，转换器仍然可用该模式实现。

类图如下

 

    internal class Program
    {
        static void Main(string[] args)
        {
            //创建环境对象
            Context context = new Context();

            //创建多个变量对象
            VariableExpression a = new VariableExpression("a");
            VariableExpression b = new VariableExpression("b");
            VariableExpression c = new VariableExpression("c");
            VariableExpression d = new VariableExpression("d");

            //将变量存储到环境对象中
            context.Assign(a, 1);
            context.Assign(b, 2);
            context.Assign(c, 3);
            context.Assign(d, 4);

            //获取抽象语法树
            AbstractExpression expression = new AddExpresssion(new MunusExpresssion(c, new AddExpresssion(a, b)), d);

            int result = expression.Interprete(context);

            Console.WriteLine(expression.ToString() + "=" + result);
        }
    }

    /// <summary>
    /// 抽象表达式类，声明一个解释操作
    /// </summary>
    internal abstract class AbstractExpression
    {
        //返回值为int类型的解释器方法
        public abstract int Interprete(Context context);
    }

    /// <summary>
    /// 环境角色类
    /// </summary>
    internal class Context
    {
        //定义一个键值对，用来存储变量以及对应的值
        private Dictionary<VariableExpression, int> variables = new Dictionary<VariableExpression, int>();

        //添加变量的功能
        public void Assign(VariableExpression variable, int value)
        {
            variables.Add(variable, value);
        }

        //根据变量获取对应的值
        public int GetValue(VariableExpression variable)
        {
            return variables[variable];
        }
    }

    /// <summary>
    /// 终结符表达式类，封装数值
    /// </summary>
    internal class VariableExpression : AbstractExpression
    {
        //数据名称
        private string name;
        public VariableExpression(string name)
        {
            this.name = name;
        }
        public override int Interprete(Context context)
        {
            //返回变量值
            return context.GetValue(this);
        }

        public override string ToString()
        {
            return name;
        }
    }

    /// <summary>
    /// 非终结表达式类，封装加法
    /// </summary>
    internal class AddExpresssion : AbstractExpression
    {
        private AbstractExpression left;
        private AbstractExpression right;
        public AddExpresssion(AbstractExpression left, AbstractExpression right)
        {
            this.left = left;
            this.right = right;
        }
        public override int Interprete(Context context)
        {
            //将左边表达式的结果与右边表达式的结果相加
            return left.Interprete(context) + right.Interprete(context);
        }

        public override string ToString()
        {
            return $"({left.ToString()}+{right.ToString()})";
        }
    }

    /// <summary>
    /// 非终结表达式类，封装减法
    /// </summary>
    internal class MunusExpresssion : AbstractExpression
    {
        private AbstractExpression left;
        private AbstractExpression right;
        public MunusExpresssion(AbstractExpression left, AbstractExpression right)
        {
            this.left = left;
            this.right = right;
        }
        public override int Interprete(Context context)
        {
            //将左边表达式的结果与右边表达式的结果相减
            return left.Interprete(context) - right.Interprete(context);
        }

        public override string ToString()
        {
            return $"({left.ToString()}-{right.ToString()})";
        }
    }