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

原文:乐在其中设计模式(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);



            ].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);



            ].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);



            ].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 ].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(].PublishTime.ToString());

    }

}

运行结果

中文语法：{数据库}[信息](获取)

解释后的C#代码：SqlMessage.Get()

执行结果：SQL方式获取Message 2007-5-1 8:48:07





参考

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





OK

[源码下载]