设计模式16：Interpreter Pattern(解释者模式)

设计模式16：Interpreter Pattern(解释者模式)

分类： 设计模式 2009-07-06 12:56 177人阅读 评论(0) 收藏 举报

本文翻译自：http://www./Patterns/PatternInterpreter.aspx

Define:Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

一、解释者模式概念

针对某一编程语言，为其语法定义一定的描述语言和解释器，解释器利用描述语言去解释该编程语言中的所有语法。

二、UML类图

 

三、参与者

该模式的类/对象参与者包括：

AbstractExpression  (描述)

• 为执行operation()声明一个接口

TerminalExpression  ( ThousandExpression, HundredExpression, TenExpression, OneExpression )

• 在语法中使用终止符实现一个operation解释器
• 在语句中要求所有终止符需要一个实例

NonterminalExpression  ( 不使用 )

• one such class is required for every rule R ::= R1R2...Rn in the grammar
• maintains instance variables of type AbstractExpression for each of the symbols R1 through Rn.
• implements an Interpret operation for nonterminal symbols in the grammar. Interpret typically calls itself recursively on the variables representing R1 through Rn.

Context  (Context)

• 所有全局解释器的内容信息

Client  (InterpreterApp)

• builds (or is given) an abstract syntax tree representing a particular sentence in the language that the grammar defines. The abstract syntax tree is assembled from instances of the NonterminalExpression and TerminalExpression classes
• invokes the Interpret operation

四、示例代码

以下结构性的代码描述解释器模式，即利用一个定义好的语法，为进程解析声明提供解释器。

 

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

namespace Interpreter_Pattern
{
    /// <summary>

    /// MainApp startup class for Structural

    /// Interpreter Design Pattern.

    /// </summary>

    class MainApp
    {

        /// <summary>

        /// Entry point into console application.

        /// </summary>

        static void Main()
        {

            Context context = new Context();

            // Usually a tree

            ArrayList list = new ArrayList();


            // Populate 'abstract syntax tree'

            list.Add(new TerminalExpression());

            list.Add(new NonterminalExpression());

            list.Add(new TerminalExpression());

            list.Add(new TerminalExpression());



            // Interpret

            foreach (AbstractExpression exp in list)
            {

                exp.Interpret(context);

            }



            // Wait for user

            Console.ReadKey();

        }

    }



    /// <summary>

    /// The 'Context' class

    /// </summary>

    class Context
    {

    }



    /// <summary>

    /// The 'AbstractExpression' abstract class

    /// </summary>

    abstract class AbstractExpression
    {

        public abstract void Interpret(Context context);

    }



    /// <summary>

    /// The 'TerminalExpression' class

    /// </summary>

    class TerminalExpression : AbstractExpression
    {

        public override void Interpret(Context context)
        {

            Console.WriteLine("Called Terminal.Interpret()");

        }

    }



    /// <summary>

    /// The 'NonterminalExpression' class

    /// </summary>

    class NonterminalExpression : AbstractExpression
    {

        public override void Interpret(Context context)
        {

            Console.WriteLine("Called Nonterminal.Interpret()");

        }

    }
}

另外一个实例即利用解释器模式来实现如何将罗马数字跟十进制的转换，代码如下：

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

namespace Interpreter_Pattern
{
    class MainApp
    {

        /// <summary>

        /// Entry point into console application.

        /// </summary>

        static void Main()
        {

            string roman = "MCMXXVIII";

            Context context = new Context(roman);



            // Build the 'parse tree'

            List<Expression> tree = new List<Expression>();

            tree.Add(new ThousandExpression());

            tree.Add(new HundredExpression());

            tree.Add(new TenExpression());

            tree.Add(new OneExpression());



            // Interpret

            foreach (Expression exp in tree)
            {

                exp.Interpret(context);

            }



            Console.WriteLine("{0} = {1}",

              roman, context.Output);



            // Wait for user

            Console.ReadKey();

        }

    }



    /// <summary>

    /// The 'Context' class

    /// </summary>

    class Context
    {

        private string _input;

        private int _output;



        // Constructor

        public Context(string input)
        {

            this._input = input;

        }



        // Gets or sets input

        public string Input
        {

            get { return _input; }

            set { _input = value; }

        }



        // Gets or sets output

        public int Output
        {

            get { return _output; }

            set { _output = value; }

        }

    }



    /// <summary>

    /// The 'AbstractExpression' class

    /// </summary>

    abstract class Expression
    {

        public void Interpret(Context context)
        {

            if (context.Input.Length == 0)

                return;



            if (context.Input.StartsWith(Nine()))
            {

                context.Output += (9 * Multiplier());

                context.Input = context.Input.Substring(2);

            }

            else if (context.Input.StartsWith(Four()))
            {

                context.Output += (4 * Multiplier());

                context.Input = context.Input.Substring(2);

            }

            else if (context.Input.StartsWith(Five()))
            {

                context.Output += (5 * Multiplier());

                context.Input = context.Input.Substring(1);

            }



            while (context.Input.StartsWith(One()))
            {

                context.Output += (1 * Multiplier());

                context.Input = context.Input.Substring(1);

            }

        }



        public abstract string One();

        public abstract string Four();

        public abstract string Five();

        public abstract string Nine();

        public abstract int Multiplier();

    }



    /// <summary>

    /// A 'TerminalExpression' class

    /// <remarks>

    /// Thousand checks for the Roman Numeral M

    /// </remarks>

    /// </summary>

    class ThousandExpression : Expression
    {

        public override string One() { return "M"; }

        public override string Four() { return " "; }

        public override string Five() { return " "; }

        public override string Nine() { return " "; }

        public override int Multiplier() { return 1000; }

    }



    /// <summary>

    /// A 'TerminalExpression' class

    /// <remarks>

    /// Hundred checks C, CD, D or CM

    /// </remarks>

    /// </summary>

    class HundredExpression : Expression
    {

        public override string One() { return "C"; }

        public override string Four() { return "CD"; }

        public override string Five() { return "D"; }

        public override string Nine() { return "CM"; }

        public override int Multiplier() { return 100; }

    }



    /// <summary>

    /// A 'TerminalExpression' class

    /// <remarks>

    /// Ten checks for X, XL, L and XC

    /// </remarks>

    /// </summary>

    class TenExpression : Expression
    {

        public override string One() { return "X"; }

        public override string Four() { return "XL"; }

        public override string Five() { return "L"; }

        public override string Nine() { return "XC"; }

        public override int Multiplier() { return 10; }

    }



    /// <summary>

    /// A 'TerminalExpression' class

    /// <remarks>

    /// One checks for I, II, III, IV, V, VI, VI, VII, VIII, IX

    /// </remarks>

    /// </summary>

    class OneExpression : Expression
    {

        public override string One() { return "I"; }

        public override string Four() { return "IV"; }

        public override string Five() { return "V"; }

        public override string Nine() { return "IX"; }

        public override int Multiplier() { return 1; }

    }
}