解释器模式(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