Interpreter解释器(行为型模式)

动机(Motivation)
在软件构建中,如果某一特定领域的问题比较复杂,类似的模式不断重复出现,如果使用普通的变成方式来实现将面临非常频繁的变化。

在这种情况下,将特定领域的问题表达为某种语法规则情况下,然后构建一个解释器(解释器并不一样)来解释这样的句子,从而达到解决问题的目的。

意图(Intent)
给定一个语言,定义它的文法的一种表示,并定义一种解释器,这个解释器使用该表示来解释语言中的句子。
                   ---《设计模式》GoF

结构(Structure)

 

代码
namespace Interpreter
{
    
public class MainApp
    {
        
static void Main()
        {
            
string romman = "六千四百五十二"//转换成6452,但是怎么解决无穷的位数?
        }
    }

    
public class Context //处理上下文类
    {
        
public Context(string xx)
        {
            Statement 
= xx;
        }
       
public string Statement;
       
public int Data;
       
    }

    
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 virtual void Interpret(Context context)
        {
            
if(context.Statement.Lenth == 0)
                
return;

            
foreach(string key in table.Keys)
            {
                
int value = table[key];
                
if(context.Statement.EndsWith(key + GetPostfix())) //如果是以此关键字结尾比如400=四百
                {
                    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 abstract string GetPostfix();
        
public abstract int Multiplier();
        
public virtual int GetLength()
        {
            
return this.GetPostfix().Length + 1;
        }
    }

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

        
public override int  GetLength()
        {
            
return 1;
        }

    }
    
    
//十, 百,千处理方法同十
    public class ShiExpression : Expression
    {
        
public override string  GetPostfix()
        {
            
return "";
        }

        
public override int  Multiplier()
        {
            
return 10;
        }
    }
    
public class BaiExpression : Expression{}
    
public class QianExpression : Expression{}
    
//万,亿等等处理类似
    public class WanExpression : Expression
    {
        
public override string  GetPostfix()
        {
            
return "";
        }

        
public override void  Interpret(Context context)
        {
            
if(context.Statement.Length == 0)
                
return;
            ArrayList tree 
= new ArrayList();
            tree.Add(
new GeExpression());
            tree.Add(
new ShiExpression());
            tree.Add(
new WanExpression());
            tree.Add(
new QianExpression());

            
foreach(string key in table.Keys)
            {
                
if(context.Statement.EndsWith(this.GetPostfix())
                {
                    
int temp = context.Data;
                    context.Data 
= 0;
                    context.Statement 
= context.Statement.Substring(0,context.Statement.Length - this.GetLength());

                    
foreach(Expression exp in tree)
                    {
                        exp.Interpret(context);
                    }

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

        
public override int  Multiplier()
        {
            
return 10000;
        }
    }
}

 

 

 Interpreter模式的几个要点

·Interpreter模式的应用场合是Interpreter模式应用中的难点,只有满足"业务规则频繁变化,且类似的模式不断重复出现,并且容易抽象为语法规则的问题"才适合使用Interpreter模式。

·使用Interpreter模式来表示文法规则,从而可以使用面向对象技巧来方便地扩展文法。

·Interpreter模式比较适合简单的文法表示,对于复杂的文法表示,Interpreter模式会产生比较大的类层次结构,需要求助于语法分析生成器这样的标准工具。



http://www.cnblogs.com/jonniexie/articles/1641826.html

阅读更多
上一篇Command命令(行为型模式)
下一篇Mediator中介者(行为型设计模式)
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭