编辑说明

概述

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

用编译语言的方式来分析应用中的实例。

结构图

代码实现

 表达式

    /// <summary>
    /// 抽象解释器(表达式)
    /// </summary>
    public abstract class AbstractExpression
    {
        public abstract void Interpret(Context context);
    }

    /// <summary>
    /// 非终端解释器(表达式)
    /// </summary>
    public class NonterminalExpression : AbstractExpression
    {
        public override void Interpret(Context context)
        {
            Console.WriteLine("非终端解释器");
        }
    }

    /// <summary>
    /// 终端解释器(表达式)
    /// </summary>
    public class TerminalExpression : AbstractExpression
    {
        public override void Interpret(Context context)
        {
            Console.WriteLine("终端解释器");
        }
    }

上下文

    /// <summary>
    /// 上下文（环境）
    /// </summary>
    public class Context
    {
        private string input;
        public string Input
        {
            get { return input; }
            set { input = value; }
        }

        private string output;
        public string Output
        {
            get { return output; }
            set { output = value; }
        }
    }

客户端

    /// <summary>
    /// 客户端
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Context context = new Context();
            IList<AbstractExpression> list = new List<AbstractExpression>();
            list.Add(new TerminalExpression());
            list.Add(new NonterminalExpression());
            list.Add(new TerminalExpression());
            list.Add(new TerminalExpression());

            foreach (AbstractExpression exp in list)
            {
                exp.Interpret(context);
            }

            Console.Read();
        }
    }

运行结果

优势

可扩展性比较好，灵活。

增加了新的解释表达式的方式。

易于实现简单文法。

使用场景

这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。

一些重复出现的问题可以用一种简单的语言来进行表达。

一个简单语法需要解释的场景。

缺陷

可利用场景比较少。

对于复杂的文法比较难维护。

解释器模式会引起类膨胀。

Demo