极速理解设计模式系列：23.解释器模式(Interpreter Pattern)

五个角色：场景(Context)、抽象表达式(Component)、终结符表达式(TerminalExpression)、非终结符表达式(NonterminalExpression)、客户端(Client) 

        场景(Context)：解释器的全局信息

        抽象表达式(Component)：定义一个接口来解释操作

        终结符表达式(TerminalExpression)：直接跳过步骤，不用解释语句

        非终结符表达式(NonterminalExpression)：根据规则实现解释操作

        客户端(Client):调用解释器，对语句进行解释。

实现思路：建立语法树，然后用语法将表达式进行解析。

类图： 

应用场景：将十六进制值解释为十进制。

分析：如果以0X开头则将十六进制解释为十进制，否则直接输出的就是十进制不需要解释。

        下面我们在控制台程序去演示一下如何使用Interpreter Pattern：

        一、 场景(Context)

  //场景(Context)
    class Context
    {
      
        public Context(string input)
        {
            this.Input = input;
        }

        /// <summary>
        /// 输入参数
        /// </summary>
        public string Input { get; set; }

        /// <summary>
        /// 输出参数
        /// </summary>
        public int Output { get; set; }

        /// <summary>
        /// 是否是十六进制 如果是转为十进制,否则不转
        /// </summary>
        public bool Status { get; set; }
    }

        二、抽象表达式(Component)

    //抽象表达式类(AbstractExpression)
    abstract class Expression
    {
        public virtual void Interpret(Context context)
        {
            if (context.Input.Length == 0)
                return;

            int multiresult = Multiplier(context);
            if (multiresult == 0)
                return;

            if(context.Input.StartsWith("F"))
            {
                context.Output += (15 * multiresult);
                context.Input=context.Input.Substring(1);
            }
            else if (context.Input.StartsWith("F"))
            {
                context.Output += (15 * multiresult);
                context.Input = context.Input.Substring(1);
            }
            else if (context.Input.StartsWith("E"))
            {
                context.Output += (14 * multiresult);
                context.Input = context.Input.Substring(1);
            }
            else if (context.Input.StartsWith("D"))
            {
                context.Output += (13 * multiresult);
                context.Input = context.Input.Substring(1);
            }
            else if (context.Input.StartsWith("C"))
            {
                context.Output += (12 * multiresult);
                context.Input = context.Input.Substring(1);
            }
            else if (context.Input.StartsWith("B"))
            {
                context.Output += (11 * multiresult);
                context.Input = context.Input.Substring(1);
            }
            else if (context.Input.StartsWith("A"))
            {
                context.Output += (10 * multiresult);
                context.Input = context.Input.Substring(1);
            }
            else
            {
                context.Output += (int.Parse(context.Input.Substring(0, 1)) * multiresult);
                context.Input = context.Input.Substring(1);
            }
        }

        //该位置需要做的乘法值
        public abstract int Multiplier(Context context);
    }

        三、终结符表达式(TerminalExpression)

   //终结符表达式(TerminalExpression)
    class NumterminalExp : Expression
    {
        public override void Interpret(Context context)
        {
            if (context.Input.StartsWith("0X"))
            {
                context.Input = context.Input.Substring(2);
                context.Status = true;
            }
            else
            { 
                context.Output = int.Parse(context.Input);
                context.Status = false;
                return;
            }
        }
        public override int Multiplier(Context context)
        {
            return 1;
        } 
    }

        四、非终结符表达式(NonterminalExpression)

    //非终结符表达式(NonterminalExpression)  千位计算
    class ThousandExp : Expression
    {
        public override int Multiplier(Context context)
        {
            if (context.Input.Length == 4&&context.Status)
                return 16 * 16 * 16;
            else
                return 0;
        }
    }

    //非终结符表达式(NonterminalExpression)  百位计算
    class HundredExp : Expression
    {
        public override int Multiplier(Context context)
        {
            if (context.Input.Length == 3 && context.Status)
                return 16 * 16;
            else
                return 0;
        }
    }

    //非终结符表达式(NonterminalExpression)  十位计算
    class TenExp : Expression
    {
        public override int Multiplier(Context context)
        {
            if (context.Input.Length == 2 && context.Status)
                return 16;
            else
                return 0;
        }
    }

    //非终结符表达式(NonterminalExpression)  个位计算
    class OneExp : Expression
    {
        public override int Multiplier(Context context)
        {
            if (context.Input.Length == 1 && context.Status)
                return 1;
            else
                return 0;
        }
    }

        五、客户端(Client)

    //客户端(Client)
    class Program
    {
        static void Main(string[] args)
        {
            string input = "0XA321";

            Context context = new Context(input.ToUpper());

            List<Expression> expTree = new List<Expression>();
            expTree.Add(new NumterminalExp());
            expTree.Add(new ThousandExp());
            expTree.Add(new HundredExp());
            expTree.Add(new TenExp());
            expTree.Add(new OneExp());
            
            foreach (Expression exp in expTree)
            {
                exp.Interpret(context);    
            }
            Console.WriteLine("十六进制数{0}转换为十进制数{1}", input, context.Output);
            Console.ReadLine();
        }
    }

       如需源码请点击 InterpreterPattern.rar 下载。