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

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; } 
                } 
        } 
}

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; 
                } 
        } 
}

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; } 
                } 
        } 
}

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(); 
        } 
}

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; 
                } 
        } 
}

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; 
                } 
        } 
}

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; 
                } 
        } 
}

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()); 
        } 
}