面向对象设计模式之Interpreter解释器模式（行为型）

 动机：在软件构建过程中 ，如果某一特定领域的问题比较复杂，类似的模式不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。在这种情况下，将特定领域的问题表达为某种语法规则的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。
意图：给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。

UML图解：

示例：接收中文形式的数字表示并能以罗马形式数字输出，应用解释器模式设计，如：四百七十一万六千四百五十二 =》4716452。代码如下

namespace Interpreter
{
    /// <summary>
    /// 定义一个数据上下文
    /// </summary>
    public class Context
    {
        string statement="";//待解释的数据
        int data;//解释之后的数据
        public Context (string statement)
        {
            this.statement = statement;
        }
        public int Data
        {
            get { return data; }
            set { data = value; }
        }
        public string Statement
        {
            get { return statement; }
            set { statement = value; }
        }


    }

    /// <summary>
    /// 抽象表达式解释器
    /// </summary>
    public abstract class Expression
    {
        protected Dictionary<string, int> table = new Dictionary<string, int>(9);
        public Expression()
        {
            table.Add("一", 1);
            table.Add("二", 2);
            table.Add("三", 3);
            table.Add("四", 4);
            table.Add("五", 5);
            table.Add("六", 6);
            table.Add("七", 7);
            table.Add("八", 8);
            table.Add("九", 9);
        }

        /// <summary>
        /// 解释给定的中文表示数字上下文对象
        /// </summary>
        /// <param name="context"></param>
        public virtual void Interpreter(Context context)
        {
            if (context.Statement.Length == 0)
            {
                return;
            }
            foreach (string key in table.Keys)
            {
                int value=table[key];
                if (context.Statement.EndsWith(key+GetPostfix()))
                {
                    context.Data += value * this.Multiplier();
                    context.Statement = context.Statement.Substring(0, context.Statement.Length - GetLength());
                }
                if (context.Statement.EndsWith("零"))//应对如"四百七十一万零六千四百零五十二"中出现'零'的情况
                {
                    context.Statement=context.Statement.Substring(0,context.Statement.Length-1);
                }
            }
        }

        /// <summary>
        /// 获取如“六千四百五十二”中，获取千位的'千'字，百位的'百'字，十位的'十'字
        /// </summary>
        /// <returns></returns>
        public abstract string GetPostfix();

        /// <summary>
        /// 陪增级数（个-1,十位-10,百位-100,千位-1000）
        /// </summary>
        /// <returns></returns>
        public abstract int Multiplier();

        /// <summary>
        /// 获取符合文法的一组长度（如获取“四百”，“五十”的长度）
        /// </summary>
        /// <returns></returns>
        public virtual int GetLength()
        {
            return this.GetPostfix().Length + 1;
        }
    }
    
    /// <summary>
    /// 个位解释器 解析个位
    /// </summary>
    public class GeExpression : Expression
    {

        public override string GetPostfix()
        {
            return "";
        }

        public override int Multiplier()
        {
            return 1;
        }


        public override int GetLength()
        {
            return  1;
        }
    }

    /// <summary>
    /// 十位解释器 解析个位+十位
    /// </summary>
    public class ShiExpression : Expression
    {

        public override string GetPostfix()
        {
            return "十";
        }

        public override int Multiplier()
        {
            return 10;
        }
    }

    /// <summary>
    /// 百位解释器 解析个位+十位+百位
    /// </summary>
    public class BaiExpresssion : Expression
    {

        public override string GetPostfix()
        {
            return "百";
        }

        public override int Multiplier()
        {
            return 100;
        }
    }

    /// <summary>
    /// 千位解释器 解析个位+十位+百位+千位
    /// </summary>
    public class QianExpression : Expression
    {

        public override string GetPostfix()
        {
            return "千";
        }

        public override int Multiplier()
        {
            return 1000;
        }
    }

    /// <summary>
    /// 万位解释器 解析个位+十位+百位+千位+万位
    /// </summary>
    public class WanExpression : Expression
    {
        public override void Interpreter(Context context)
        {
            if (context.Statement.Length == 0)
            {
                return;
            }
            ArrayList tree = new ArrayList();
            tree.Add(new GeExpression());
            tree.Add(new ShiExpression());
            tree.Add(new BaiExpresssion());
            tree.Add(new QianExpression());

            foreach (string key in table.Keys)
            {
                if (context.Statement.EndsWith(this.GetPostfix()))
                {
                    int temp = context.Data;
                    context.Data = 0;
                    context.Statement=context.Statement.Substring(0, context.Statement.Length - 1);
                    foreach(Expression expression in tree)
                    {
                        expression.Interpreter(context);
                    }
                    context.Data = temp+this.Multiplier()*context.Data;
                }
            }
           
            
        }

        public override string GetPostfix()
        {
            return "万";
        }

        public override int Multiplier()
        {
            return 10000;
        }
    }
    //通过Interpreter模式很容易扩展亿相对的YiExpression类

    public class App
    {
        public static void Main()
        {

            string chinese="四百七十一万六千四百五十二";
            Context context =new Context(chinese);
            ArrayList tree = new ArrayList();//需按顺序添加个十百千万等解释表达式对象
            tree.Add(new GeExpression());
            tree.Add(new ShiExpression());
            tree.Add(new BaiExpresssion());
            tree.Add(new QianExpression());
            tree.Add(new WanExpression());
            foreach (Expression exp in tree)
            {
                exp.Interpreter(context);
            }
            Console.WriteLine("{0}={1}",chinese,context.Data);
        }
    }
}

 Interpreter模式的几个要点：

1.Interpreter模式的应用场景时Interpreter模式应用中的难点，只有满足“业务规则频繁变化，且 类似的模式不断重复出现，并且容易抽象为语法规则的问题”才合适使用Interpreter模式。

2.使用Interpreter模式来表示文法规则，从而可以使用面向对象技巧来方便地“扩展”文法。

3.Interpreter模式比较适合简单的文法表示，对于复杂的文法表示，Interpreter模式会产生比较大的类 层次结构，需要求助于语法分析生成器这样的标准工具。