乐在其中设计模式(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
[源码下载]