五个角色：场景(Context)、抽象表达式(Component)、终结符表达式(TerminalExpression)、非终结符表达式(NonterminalExpression)、客户端(Client) 

        场景(Context)：解释器的全局信息

        抽象表达式(Component)：定义一个接口来解释操作

        终结符表达式(TerminalExpression)：直接跳过步骤，不用解释语句

        非终结符表达式(NonterminalExpression)：根据规则实现解释操作

        客户端(Client):调用解释器，对语句进行解释。

实现思路：建立语法树，然后用语法将表达式进行解析。

类图： 

 

应用场景：将十六进制值解释为十进制。

分析：如果以0X开头则将十六进制解释为十进制，否则直接输出的就是十进制不需要解释。

        下面我们在控制台程序去演示一下如何使用Interpreter Pattern：

        一、 场景(Context)

 

1. //场景(Context) 
2.   class Context 
3.   { 
4.      
5.       public Context(string input) 
6.       { 
7.           this.Input = input; 
8.       } 
9.  
10.       /// <summary> 
11.       /// 输入参数 
12.       /// </summary> 
13.       public string Input { get; set; } 
14.  
15.       /// <summary> 
16.       /// 输出参数 
17.       /// </summary> 
18.       public int Output { get; set; } 
19.  
20.       /// <summary> 
21.       /// 是否是十六进制 如果是转为十进制,否则不转 
22.       /// </summary> 
23.       public bool Status { get; set; } 
24.   } 

        二、抽象表达式(Component)

 

1. //抽象表达式类(AbstractExpression) 
2. abstract class Expression 
3. { 
4.     public virtual void Interpret(Context context) 
5.     { 
6.         if (context.Input.Length == 0) 
7.             return; 
8.  
9.         int multiresult = Multiplier(context); 
10.         if (multiresult == 0) 
11.             return; 
12.  
13.         if(context.Input.StartsWith("F")) 
14.         { 
15.             context.Output += (15 * multiresult); 
16.             context.Input=context.Input.Substring(1); 
17.         } 
18.         else if (context.Input.StartsWith("F")) 
19.         { 
20.             context.Output += (15 * multiresult); 
21.             context.Input = context.Input.Substring(1); 
22.         } 
23.         else if (context.Input.StartsWith("E")) 
24.         { 
25.             context.Output += (14 * multiresult); 
26.             context.Input = context.Input.Substring(1); 
27.         } 
28.         else if (context.Input.StartsWith("D")) 
29.         { 
30.             context.Output += (13 * multiresult); 
31.             context.Input = context.Input.Substring(1); 
32.         } 
33.         else if (context.Input.StartsWith("C")) 
34.         { 
35.             context.Output += (12 * multiresult); 
36.             context.Input = context.Input.Substring(1); 
37.         } 
38.         else if (context.Input.StartsWith("B")) 
39.         { 
40.             context.Output += (11 * multiresult); 
41.             context.Input = context.Input.Substring(1); 
42.         } 
43.         else if (context.Input.StartsWith("A")) 
44.         { 
45.             context.Output += (10 * multiresult); 
46.             context.Input = context.Input.Substring(1); 
47.         } 
48.         else 
49.         { 
50.             context.Output += (int.Parse(context.Input.Substring(0, 1)) * multiresult); 
51.             context.Input = context.Input.Substring(1); 
52.         } 
53.     } 
54.  
55.     //该位置需要做的乘法值 
56.     public abstract int Multiplier(Context context); 
57. } 

        三、终结符表达式(TerminalExpression)

 

1. //终结符表达式(TerminalExpression) 
2.  class NumterminalExp : Expression 
3.  { 
4.      public override void Interpret(Context context) 
5.      { 
6.          if (context.Input.StartsWith("0X")) 
7.          { 
8.              context.Input = context.Input.Substring(2); 
9.              context.Status = true; 
10.          } 
11.          else 
12.          {  
13.              context.Output = int.Parse(context.Input); 
14.              context.Status = false; 
15.              return; 
16.          } 
17.      } 
18.      public override int Multiplier(Context context) 
19.      { 
20.          return 1; 
21.      }  
22.  } 

        四、非终结符表达式(NonterminalExpression)

 

1. //非终结符表达式(NonterminalExpression)  千位计算 
2. class ThousandExp : Expression 
3. { 
4.     public override int Multiplier(Context context) 
5.     { 
6.         if (context.Input.Length == 4&&context.Status) 
7.             return 16 * 16 * 16; 
8.         else 
9.             return 0; 
10.     } 
11. } 
12.  
13. //非终结符表达式(NonterminalExpression)  百位计算 
14. class HundredExp : Expression 
15. { 
16.     public override int Multiplier(Context context) 
17.     { 
18.         if (context.Input.Length == 3 && context.Status) 
19.             return 16 * 16; 
20.         else 
21.             return 0; 
22.     } 
23. } 
24.  
25. //非终结符表达式(NonterminalExpression)  十位计算 
26. class TenExp : Expression 
27. { 
28.     public override int Multiplier(Context context) 
29.     { 
30.         if (context.Input.Length == 2 && context.Status) 
31.             return 16; 
32.         else 
33.             return 0; 
34.     } 
35. } 
36.  
37. //非终结符表达式(NonterminalExpression)  个位计算 
38. class OneExp : Expression 
39. { 
40.     public override int Multiplier(Context context) 
41.     { 
42.         if (context.Input.Length == 1 && context.Status) 
43.             return 1; 
44.         else 
45.             return 0; 
46.     } 
47. } 

        五、客户端(Client)

 

1. //客户端(Client) 
2. class Program 
3. { 
4.     static void Main(string[] args) 
5.     { 
6.         string input = "0XA321"; 
7.  
8.         Context context = new Context(input.ToUpper()); 
9.  
10.         List<Expression> expTree = new List<Expression>(); 
11.         expTree.Add(new NumterminalExp()); 
12.         expTree.Add(new ThousandExp()); 
13.         expTree.Add(new HundredExp()); 
14.         expTree.Add(new TenExp()); 
15.         expTree.Add(new OneExp()); 
16.          
17.         foreach (Expression exp in expTree) 
18.         { 
19.             exp.Interpret(context);     
20.         } 
21.         Console.WriteLine("十六进制数{0}转换为十进制数{1}", input, context.Output); 
22.         Console.ReadLine(); 
23.     } 
24. } 

       如需源码请点击 InterpreterPattern.rar 下载

本文转自程兴亮 51CTO博客，原文链接:http://blog.51cto.com/chengxingliang/827101