.NET乐园
一个梦想,一个行动…… (欢迎光临我的淘宝http://pipis.taobao.com,专营户外手电筒、头灯、营地灯、自行车灯)
动机:在软件构建过程中,如果某一特定领域的问题比较复杂,类似的模式不断重复出现,如果使用普通的编程方式来实现将面临非常频繁的变化。将特定领域的问题表达为某种语法规则下的句子,然后构建一个解释器来解释这样的句子,从而达到解决问题的目的。

场景:把中文数字转换成罗马数字,如把九万九千九百九十九转换成99999,并且方便扩展到其它位,如扩展到亿位。


结构
Interpreter模式结构图

代码

/*
 * 上下文
*/

namespace DesignPattern.Interpreter
{
    
public class Context
    
{
        
private string statement;
        
private int data;

        
public Context(string statement)
        
{
            
this.statement = statement;
        }


        
public string Statement
        
{
            
get
            
{
                
return statement;
            }

            
set
            
{
                statement 
= value;
            }

        }


        
public int Data
        
{
            
get
            
{
                
return data;
            }

            
set
            
{
                data 
= value;
            }

        }

    }

}

/*
 * 解释器
*/

namespace DesignPattern.Interpreter
{
    
public abstract class Expression
    
{
        
protected Dictionary<stringint> table = new Dictionary<stringint>(9);

        
public Expression()
        
{
            table.Add(
""1);
            table.Add(
""2);
            table.Add(
""3);
            table.Add(
""4);
            table.Add(
""5);
            table.Add(
""6);
            table.Add(
""7);
            table.Add(
""8);
            table.Add(
""9);
        }


        
public abstract string GetPostfix();

        
public abstract int Multiplier();

        
public virtual int GetLength()
        
{
            
return this.GetPostfix().Length + 1;
        }


        
public virtual void Interpreter(Context context)
        
{
            
if (context.Statement.Length == 0)
            
{
                
return;
            }


            
foreach (string key in table.Keys)
            
{
                
int value = table[key];
                
if (context.Statement.EndsWith(key + GetPostfix()))
                
{
                    context.Data 
+= value * this.Multiplier();
                    context.Statement 
= context.Statement.Substring(0, context.Statement.Length - this.GetLength());
                }


                
if (context.Statement.EndsWith(""))
                
{
                    context.Statement 
= context.Statement.Substring(0, context.Statement.Length - this.GetLength());
                }

            }

        }

    }


    
public class GeExpression : Expression
    
{
        
public override string GetPostfix()
        
{
            
return "";
        }


        
public override int Multiplier()
        
{
            
return 1;
        }

    }


    
public class ShiExpression : Expression
    
{
        
public override string GetPostfix()
        
{
            
return "";
        }


        
public override int Multiplier()
        
{
            
return 10;
        }

    }


    
public class BaiExpression : Expression
    
{
        
public override string GetPostfix()
        
{
            
return "";
        }


        
public override int Multiplier()
        
{
            
return 100;
        }

    }


    
public class QianExpression : Expression
    
{
        
public override string GetPostfix()
        
{
            
return "";
        }


        
public override int Multiplier()
        
{
            
return 1000;
        }

    }


    
public class WanExpression : Expression
    
{
        
public override string GetPostfix()
        
{
            
return "";
        }


        
public override int Multiplier()
        
{
            
return 10000;
        }


        
public override void Interpreter(Context context)
        
{
            
if (context.Statement.Length == 0)
            
{
                
return;
            }


            IList
<Expression> expressionCollection = new List<Expression>();
            expressionCollection.Add(
new GeExpression());
            expressionCollection.Add(
new ShiExpression());
            expressionCollection.Add(
new BaiExpression());
            expressionCollection.Add(
new QianExpression());

            
foreach (string key in table.Keys)
            
{
                
int temp = context.Data;
                context.Data 
= 0;
                context.Statement 
= context.Statement.Substring(0, context.Statement.Length - 1);

                
foreach(Expression expression in expressionCollection)
                
{
                    expression.Interpreter(context);
                }


                context.Data 
+= temp + this.Multiplier() * context.Data;
            }

        }

    }

}

/*
 * 客户程序
*/

namespace DesignPattern.Interpreter
{
    
public class Client
    
{
        
private string chineseDigit;
        
private Context context;
        IList
<Expression> expressionCollection = new List<Expression>();

        
public Client(string chineseDigit)
        
{
            
this.chineseDigit = chineseDigit;
            context 
= new Context(chineseDigit);

            expressionCollection.Add(
new GeExpression());
            expressionCollection.Add(
new ShiExpression());
            expressionCollection.Add(
new BaiExpression());
            expressionCollection.Add(
new QianExpression());
        }


        
public string ChineseDigit
        
{
            
get
            
{
                
return chineseDigit;
            }

            
set
            
{
                value 
= chineseDigit;
            }

        }


        
public int GetRomanDigit()
        
{
            
foreach (Expression expression in expressionCollection)
            
{
                expression.Interpreter(context);
            }

            
return context.Data;
        }

    }

}


要点
      1、本模式应用场景:只有满足“业务规则频繁变化,且类似的模式不断重复出现,并且容易抽象成语法规则的问题”。
      2、使用本模式来表达文法规则,从而可以使用面向对象技巧来方便地扩展文法。
      3、本模式比较适合简单的文法表示,对于复杂的文法表示,本模式会产生比较大的类层次结构,需要求助于语法分析生成器这样的标准工具。
posted on 2007-07-17 00:42  Charly  阅读(572)  评论(0编辑  收藏  举报