解释器模式(Interpreter Pattern)

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

示例
有一个Message实体类，某个类对它的操作有Get()方法。现在要求用具有某一规则的中文语法来执行这个操作。

技术分享

　　MessageModel

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

namespace Pattern.Interpreter
{
    /// <summary>
    /// Message实体类
   /// </summary>
    public class MessageModel
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="msg">Message内容</param>
       /// <param name="pt">Message发布时间</param>
        public MessageModel(string msg, DateTime pt)
        {
            this._message = msg;
            this._publishTime = pt;
       }

        private string _message;
        /// <summary>
        /// Message内容
       /// </summary>
        public string Message
        {
            get { return _message; }
            set { _message = value; }
       }

        private DateTime _publishTime;
        /// <summary>
        /// Message发布时间
       /// </summary>
        public DateTime PublishTime
        {
            get { return _publishTime; }
            set { _publishTime = value; }
       }
   }
}

　　SqlMessage

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

namespace Pattern.Interpreter
{
    /// <summary>
    /// Sql方式操作Message
   /// </summary>
    public class SqlMessage
    {
        /// <summary>
        /// 获取Message
        /// </summary>
       /// <returns></returns>
        public static List<MessageModel> Get()
        {
            List<MessageModel> l = new List<MessageModel>();
            l.Add(new MessageModel("SQL方式获取Message", DateTime.Now));

            return l;
       }
   }
}

　　Context

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

namespace Pattern.Interpreter
{
    /// <summary>
    /// Context
   /// </summary>
    public class Context
    {
        private string _input;
        private string _output;

        /// <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>
        public string Output
        {
            get { return _output; }
            set { _output = value; }
       }
   }
}

　　AbstractExpression

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

namespace Pattern.Interpreter
{
    /// <summary>
    /// 抽象公式（AbstractExpression）
   /// </summary>
    public abstract class AbstractExpression
    {
        /// <summary>
        /// 解释Context的方法
        /// </summary>
       /// <param name="context">context</param>
        public void Interpret(Context context)
        {
            if (String.IsNullOrEmpty(context.Input))
            {
                return;
           }

            context.Output += GetCSharp(context.Input);
       }

        /// <summary>
        /// 获得输入内容所对应的C#代码
        /// </summary>
        /// <param name="source">source</param>
       /// <returns></returns>
        private string GetCSharp(string source)
        {
            string csharp = "";
            string word = "";

            // 从输入内容中取得要解释的词
            word = GetWord(source);

            // 从字典中找到word所对应的C#代码
            GetDictionary().TryGetValue(word, out csharp);

            return csharp;
       }

        /// <summary>
        /// 从输入内容中取得要解释的词
        /// </summary>
        /// <param name="source">source</param>
       /// <returns></returns>
        public abstract string GetWord(string source);

        /// <summary>
        /// 获取字典
        /// </summary>
       /// <returns></returns>
        public abstract Dictionary<string, string> GetDictionary();
   }
}

　　DatabaseExpression

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

using System.Text.RegularExpressions;

namespace Pattern.Interpreter
{
    /// <summary>
    /// 终端公式（TerminalExpression）分析与数据库相关的
   /// </summary>
    public class DatabaseExpression : AbstractExpression
    {
        /// <summary>
        /// 从输入内容中取得要解释的词
        /// </summary>
        /// <param name="source">source</param>
       /// <returns></returns>
        public override string GetWord(string source)
        {
            MatchCollection mc;
            Regex r = new Regex(@"\{(.*)\}");
            mc = r.Matches(source);

            return mc[0].Groups[1].Value;
       }

        /// <summary>
        /// 获取与数据库相关的字典
        /// </summary>
       /// <returns></returns>
        public override Dictionary<string, string> GetDictionary()
        {
            Dictionary<string, string> d = new Dictionary<string, string>();

            d.Add("数据库", "Sql");

            return d;
       }
   }
}

　　ObjectExpression

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

using System.Text.RegularExpressions;

namespace Pattern.Interpreter
{
    /// <summary>
    /// 终端公式（TerminalExpression）分析与对象相关的
   /// </summary>
    public class ObjectExpression : AbstractExpression
    {
        /// <summary>
        /// 从输入内容中取得要解释的词
        /// </summary>
        /// <param name="source">source</param>
       /// <returns></returns>
        public override string GetWord(string source)
        {
            MatchCollection mc;
            Regex r = new Regex(@"\[(.*)\]");
            mc = r.Matches(source);

            return mc[0].Groups[1].Value;
       }

        /// <summary>
        /// 获取与对象相关的字典
        /// </summary>
       /// <returns></returns>
        public override Dictionary<string, string> GetDictionary()
        {
            Dictionary<string, string> d = new Dictionary<string, string>();

            d.Add("信息", "Message");

            return d;
       }
   }
}

　　MethodExpression

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

using System.Text.RegularExpressions;

namespace Pattern.Interpreter
{
    /// <summary>
    /// 终端公式（TerminalExpression）分析与方法相关的
   /// </summary>
    public class MethodExpression : AbstractExpression
    {
        /// <summary>
        /// 从输入内容中取得要解释的词
        /// </summary>
        /// <param name="source">source</param>
       /// <returns></returns>
        public override string GetWord(string source)
        {
            MatchCollection mc;
            Regex r = new Regex(@"\((.*)\)");
            mc = r.Matches(source);

            return mc[0].Groups[1].Value;
       }

        /// <summary>
        /// 获取与方法相关的字典
        /// </summary>
       /// <returns></returns>
        public override Dictionary<string, string> GetDictionary()
        {
            Dictionary<string, string> d = new Dictionary<string, string>();

            d.Add("获取", ".Get()");

            return d;
       }
   }
}

　　Client

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

using Microsoft.CSharp;
using System.Reflection;
using System.Text;
using System.Collections.Generic;

using Pattern.Interpreter;

public partial class Interpreter : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        string chinese = "{数据库}[信息](获取)";
        Context context = new Context(chinese);

        List<AbstractExpression> l = new List<AbstractExpression>();
        l.Add(new DatabaseExpression());
        l.Add(new ObjectExpression());
        l.Add(new MethodExpression());

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

        Assembly assembly = Assembly.Load("Pattern.Interpreter");
        MethodInfo method = assembly.GetType("Pattern.Interpreter." + context.Output.Split(‘.‘)[0]).GetMethod(context.Output.Split(‘.‘)[1].Replace("()", ""));
        object obj = method.Invoke(null, null);

        List<MessageModel> m = (List<MessageModel>)obj;

        Response.Write("中文语法：" + chinese);
        Response.Write("<br />");
        Response.Write("解释后的C#代码：" + context.Output);
        Response.Write("<br />");
        Response.Write("执行结果：" + m[0].Message + " " + m[0].PublishTime.ToString());
   }
}

　　运行结果
　　中文语法：{数据库}[信息](获取)
　　解释后的C#代码：SqlMessage.Get()
　　执行结果：SQL方式获取Message 2007-5-1 8:48:07

二十四种设计模式：解释器模式(Interpreter Pattern)

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 二十四种设计模式：解释器模式(Interpreter Pattern)

二十四种设计模式：解释器模式(Interpreter Pattern)

解释器模式(Interpreter Pattern)

看完仍有疑问？有类似问题直接问程序猿