Interpreter解释器(行为型模式)

动机(Motivation)

在软件构建中，如果某一特定领域的问题比较复杂，类似的模式不断重复出现，如果使用普通的变成方式来实现将面临非常频繁的变化。

在这种情况下，将特定领域的问题表达为某种语法规则情况下，然后构建一个解释器(解释器并不一样)来解释这样的句子，从而达到解决问题的目的。

意图(Intent)

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

                   ---《设计模式》GoF

结构(Structure)

 

namespace Interpreter
{
    public class MainApp
    {
        static void Main()
        {
            string romman = "六千四百五十二"; //转换成6452,但是怎么解决无穷的位数？
        }
    }

    public class Context //处理上下文类
    {
        public Context(string xx)
        {
            Statement = xx;
        }
       public string Statement;
       public int Data;
       
    }

    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);
        }

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

            foreach(string key in table.Keys)
            {
                int value = table[key];
                if(context.Statement.EndsWith(key + GetPostfix())) //如果是以此关键字结尾比如400=四百
                {
                    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 - this.GetLength());
                }
            }
        }

        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  GetLength()
        {
            return 1;
        }

    }
    
    //十， 百，千处理方法同十
    public class ShiExpression : Expression
    {
        public override string  GetPostfix()
        {
            return "十";
        }

        public override int  Multiplier()
        {
            return 10;
        }
    }
    public class BaiExpression : Expression{}
    public class QianExpression : Expression{}
    //万，亿等等处理类似
    public class WanExpression : Expression
    {
        public override string  GetPostfix()
        {
            return "万";
        }

        public override void  Interpret(Context context)
        {
            if(context.Statement.Length == 0)
                return;
            ArrayList tree = new ArrayList();
            tree.Add(new GeExpression());
            tree.Add(new ShiExpression());
            tree.Add(new WanExpression());
            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 - this.GetLength());

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

                    context.Data = temp + this.Multiplier()*context.Data;
                }
            }
        }

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