二十四种设计模式：解释器模式(Interpreter Pattern)
解释器模式(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
