设计模式学习日志(16)-Interpreter解释器(行为型模式)

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

意图：
　　给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。
　　出自：《设计模式》GoF

Interpreter模式的几个要点：
　　１、Interpreter模式的应用场合是Interpreter模式应用中的难点，只有满足“业务规则频繁变化，且类似的模式重复出现，并且容易抽象为语法的问题”才适合使用Interpreter模式。
　　２、使用Interpreter模式来表示文法规则，从而可以使用面向对象技巧来方便地“扩展”文法。
　　３、Interpreter模式比较适合简单的文法表示，对于复杂的文法表示，Interpreter模式会产生比较大的类层次结构，需要求助于语法分析生成器这样的标准工具。

稳定部分：

    public abstract class Expression
    {
        protected Dictionary<string, int> talbe = new Dictionary<string, int>(9);
        pulbic 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);
        }

        public virtual void Interpret(Context context)
        {
            if (context.Statement.Length == 0)
            {
                return;
            }

            foreach (string key in table.Keys)
            {
                int value = table[key];
                
                if (context.Statement.EndsWith(key + this.GetPostfix()))
                {
                    context.Data += value * this.Multiplier();
                    context.Statement = context.Statement.Substring(0, context.Statement.Length - this.GetLength);
                }

                if (context.Statement.EndsWith("零"))
                {
                    context.Statement = context.Statement.Substring(0, context.Statement.Length - 1);
                }
            }
        }

        public abstract string GetPostfix();
        public abstract int Multiplier();
        public virtual int GetLength()
        {
            return this.GetPostfix().Length + 1;
        }
    }

变化部分：

public class GeExpression : Expression
    {
        public override string GetPostfix()
        {
            return "";
        }

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

    public class ShiExpression : Expression
    {
        public override string GetPostfix()
        {
            return "十";
        }

        public override int Multiplier()
        {
            return 10;
        }
    }
    public class BaiExpression : Expression
    {
        public override string GetPostfix()
        {
            return "百";
        }

        public override int Multiplier()
        {
            return 100;
        }
    }
    public class QianExpression : Expression
    {
        public override string GetPostfix()
        {
            return "千";
        }

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

    public class WanExpression : Expression
    {
        public override string GetPostfix()
        {
            return "万";
        }

        public override int Multiplier()
        {
            return 10000;
        }

        //不能解释"万万"的情况
        public override string Interpret(Context context)
        {
            if (context.Statement.Length == 0)
                return;

            ArrayList tree = new ArrayList();
            tree.Add(new GeExpression());
            tree.Add(new ShiExpression());
            tree.Add(new BaiExpression());
            tree.Add(new QianExpression());
 
            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 exp in tree)
                {
                    exp.Interpret(context);
                }
                context.Data = temp + this.Multiplier() * context.Data;
            }
        
        }
    }

    public class Context
    {
        private string statement;
        private int data;

        public Context(string statement)
        {
            this.statement = statement;
        }

        public string Statement
        {
            get { return statement; }
            set { statement = value; }
        }

        public string Data
        {
            get { return data; }
            set { data = value; }
        }
    }

主程序：

        public static void Main()
        {
            string roman = "五十七万六千四百五十二"; //==>576452

            Context context = new Context(roman);

            ArrayList tree = new ArrayList();
            tree.Add(new GeExpression());
            tree.Add(new ShiExpression());
            tree.Add(new BaiExpression());
            tree.Add(new QianExpression());
            tree.Add(new WanExpression());

            foreach (Expression exp in tree)
            {
                exp.Interpret(context);
            }

            Console.WriteLine("{0} = {1}",roman, context.Data);
        }