解释器模式(Interpreter Pattern)

     解释器模式就是定义语言的文法,并且建立一个解释器来解释该语言中的句子。

     给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表 文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。[1]

     解释器模式也可以生成一个可执行的对象，但是解释器模式需要创建一个类层次结构，在这个类层次结构中，每个类实现(或解释)了一个公共操作，类的名称也表明了这个类是如何实现这个公共操作的。

     解释器模式、状态模式、策略模式具有一个共同的特定特点：使用类都实现了一个公共操作，但是为了实现这个公共操作，每个都使用了一种不同的方式。

     解释器模式本身是一些类组成的一个集合，在一个典型的层次结构中，一般至少包括两个类。解释器模式可以从一个类层次中生成可执行对象，这个类层次结构中的类为一个公共操作提供了不同解释。相比之下，命令模式只在一个对象中封装一个请求。

     使用解释器模式的目的在于我们定义一组合成规则，利用解释器模式生成可执行对象。

     示例代码如下:

using System;
using System.Collections.Generic;
using System.Text;

namespace InterpreterPattern
...{
    /**//// <summary>
    /// 上下文（环境）角色类：包含解释器之外的一些全局信息。
    /// </summary>
    public class Context
    ...{
        /**//// <summary>
        /// 变量对象集合
        /// </summary>
        private IDictionary<CharExpression, int> charExpressions = new Dictionary<CharExpression, int>();

        private string _input;

        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="input">输入内容</param>
        public Context(string input)
        ...{
            this._input = input;
        }

        /**//// <summary>
        /// 输入内容
        /// </summary>
        public string Input
        ...{
            get ...{ return _input; }
            set ...{ _input = value; }
        }

        /**//// <summary>
        /// 设置变量的值
        /// </summary>
        /// <param name="charExpression">变量</param>
        /// <param name="number">值</param>
        public void SetValue(CharExpression charExpression, int number)
        ...{
            if (!charExpressions.ContainsKey(charExpression))
            ...{
                charExpressions.Add(charExpression, number);
            }
            else
            ...{
                charExpressions[charExpression] = number;
            }
        }

        /**//// <summary>
        /// 获得变量的值
        /// </summary>
        /// <param name="charExpression">变量</param>
        /// <returns>值</returns>
        public int GetValue(CharExpression charExpression)
        ...{
            int number = 0;
            if (charExpressions.ContainsKey(charExpression))
            ...{
                number = charExpressions[charExpression];
            }
            return number;
        }
    }


    /**//// <summary>
    /// 抽象表达式类：声明一个抽象的解释操作，抽象语法树中所有的节点共享该抽象类。
    /// </summary>
    public abstract class AbstractExpression
    ...{
        /**//// <summary>
        /// 解释操作，完成具体的语法分析
        /// </summary>
        /// <param name="context">上下文</param>
        /// <returns>结果</returns>
        public abstract int Interpret(Context context);
    }


    /**//// <summary>
    /// 终结符表达式（TerminalExpression）角色类一：实现与文法中的终结符相关联的解释操作，一个句子中的每个终结符需要该类的一个实例 。
    /// 该类处理数字。
    /// </summary>
    public class NumnerExpression : AbstractExpression
    ...{
        private int number;

        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="number">数字</param>
        public NumnerExpression(int number)
        ...{
            this.number = number;
        }

        /**//// <summary>
        /// 解释操作，完成具体的语法分析
        /// </summary>
        /// <param name="context">上下文</param>
        /// <returns>结果</returns>
        public override int Interpret(Context context)
        ...{
            return number;
        }
    }

    /**//// <summary>
    /// 终结符表达式（TerminalExpression）角色类二：实现与文法中的终结符相关联的解释操作，一个句子中的每个终结符需要该类的一个实例 。
    /// 该类处理字符。
    /// </summary>
    public class CharExpression : AbstractExpression
    ...{
        /**//// <summary>
        /// 解释操作，完成具体的语法分析
        /// </summary>
        /// <param name="context">上下文</param>
        /// <returns>结果</returns>
        public override int Interpret(Context context)
        ...{
            return context.GetValue(this);
        }
    }

 
    /**//// <summary>
    /// 非终结符表达式（NonterminalExpression）角色类一：文法中的每条规则R::=R1R2…Rn都需要一个非终结符表带式角色，对于从R1到Rn的每个符号都维护一个抽象表达式角色的实例变量
    /// 解释一般要递归地调用表示从R1到Rn的那些对象的解释操作
    /// 该类处理加号。
    /// </summary>
    public class AddExpression : AbstractExpression
    ...{
        private AbstractExpression _left;
        private AbstractExpression _right;

        public AddExpression(AbstractExpression left, AbstractExpression right)
        ...{
            this._left = left;
            this._right = right;
        }

        /**//// <summary>
        /// 左部分
        /// </summary>
        public AbstractExpression Left
        ...{
            get ...{ return _left; }
            set ...{ _left = value; }
        }

        /**//// <summary>
        /// 右部分
        /// </summary>
        public AbstractExpression Right
        ...{
            get ...{ return _right; }
            set ...{ _right = value; }
        }

        /**//// <summary>
        /// 解释操作，完成具体的语法分析
        /// </summary>
        /// <param name="context">上下文</param>
        /// <returns>结果</returns>
        public override int Interpret(Context context)
        ...{
            return _left.Interpret(context) + _right.Interpret(context);
        }
    }

    /**//// <summary>
    /// 非终结符表达式（NonterminalExpression）角色类二：文法中的每条规则R::=R1R2…Rn都需要一个非终结符表带式角色，对于从R1到Rn的每个符号都维护一个抽象表达式角色的实例变量
    /// 解释一般要递归地调用表示从R1到Rn的那些对象的解释操作
    /// 该类处理减号。
    /// </summary>
    public class SubtractExpression : AbstractExpression
    ...{
        private AbstractExpression _left;
        private AbstractExpression _right;

        public SubtractExpression(AbstractExpression left, AbstractExpression right)
        ...{
            this._left = left;
            this._right = right;
        }

        /**//// <summary>
        /// 左部分
        /// </summary>
        public AbstractExpression Left
        ...{
            get ...{ return _left; }
            set ...{ _left = value; }
        }

        /**//// <summary>
        /// 右部分
        /// </summary>
        public AbstractExpression Right
        ...{
            get ...{ return _right; }
            set ...{ _right = value; }
        }

        /**//// <summary>
        /// 解释操作，完成具体的语法分析
        /// </summary>
        /// <param name="context">上下文</param>
        /// <returns>结果</returns>
        public override int Interpret(Context context)
        ...{
            return _left.Interpret(context) - _right.Interpret(context);
        }
    }


    class Program
    ...{
        static void Main(string[] args)
        ...{
            string input = "a-(b+2)";

            Context context = new Context(input);
            NumnerExpression num = new NumnerExpression(2);
            CharExpression a = new CharExpression();
            CharExpression b = new CharExpression();
            //赋值
            context.SetValue(a, 5);
            context.SetValue(b, 1);
            AbstractExpression expression = new SubtractExpression(a, new AddExpression(b, num));

            Console.WriteLine("结果：{0}", expression.Interpret(context));
            Console.ReadLine();
        }
    }
}

[1] user.qzone.qq.com/199525784/blog/3
[2]http://www.cnblogs.com/webabcd/archive/2007/05/01/733887.html
[3]http://www.cnblogs.com/singlepine/archive/2005/10/30/265022.html
[4]http://www.pcdog.com/edu/java/2005/08/y062565_2.html