乐在其中设计模式(C#) - 解释器模式(Interpreter Pattern)

[索引页]
[×××]

乐在其中设计模式(C#) - 解释器模式(Interpreter Pattern)

作者：webabcd


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


示例
有一个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 


参考
http://www.dofactory.com/Patterns/PatternInterpreter.aspx


OK
[×××]