设计模式深入学习--Interpreter 解释器模式(行为型模式)

   今天我们来介绍下 Interpreter 解释器模式。Interpreter 解释器模式我们能用到的地方有很多，比如我们经常用的金额 用数字转中文字，10000转成中文就是一万。 顾名思义，这个设计模式就是一个解释器，通过你输入的一个类型转成另外一个类型出来，在我们的sql查询数据库里面更加有大量的运用。我们先来看懂下基础代码，然后最后实现一个 我们游戏中的中英文切换功能。

class Context
{
    private string input;
 
    public string Input
    {
        get { return input; }
        set { input = value; }
    }
 
    private string output;
 
    public string Output
    {
        get { return output; }
        set { output = value; }
    }
}
abstract class AbstractExpression
{
    public abstract void Interpret(Context context);
}
 
class TerminalExpression : AbstractExpression
{
    public override void Interpret(Context context)
    {
        Console.WriteLine("终端解释器");
    }
}
 
class NonterminalExpression : AbstractExpression
{
    public override void Interpret(Context context)
    {
        Console.WriteLine("非终端解释器");
    }
}

   首先我们定义一个Context的内容类，装有input 和output两个内容。然后是一个虚拟翻译类AbstractExpression。 里面有一个虚拟方法，可以传入一个Context。 最后是两个实体翻译类TerminalExpression类和NonterminalExpression类，都是实际操作的翻译类，这时各自都输出一句话示意。再来看实现：

Context context = new Context();
        List<AbstractExpression> lists = new List<AbstractExpression>();
        lists.Add(new TerminalExpression());
        lists.Add(new NonterminalExpression());
        lists.Add(new TerminalExpression());
        lists.Add(new TerminalExpression());
 
        foreach (AbstractExpression exp in lists)
        {
            exp.Interpret(context);
        }

        新new一个contex内容类，一个虚拟翻译AbstractExpression表单，然后添加实体翻译类，最后循环调用：Interpret输出。

 

    基本的逻辑框架就是这样，是不是非常简单呢，好 现在我们再来升华下内容，做一个我们玩游戏中经常会有一个中英文切换功能。

/// <summary>
/// 中英文翻译对照字典
/// </summary>
public static class ChineseToEnglishDict
{
    private static Dictionary<string,string> _dictory=new Dictionary<string, string>();
 
    static ChineseToEnglishDict()
    {
        _dictory.Add("friends", "好友");
        _dictory.Add("backpack", "背包");
        _dictory.Add("skills", "技能");
        _dictory.Add("community", "社区");
        _dictory.Add("activities ", "活动");
        _dictory.Add("tools", "工具");
        _dictory.Add("other ", "其他");
    }
 
    public static string GetChinese(string value)
    {
        if (_dictory.ContainsKey(value))
        {
            return _dictory[value];
        }
        return value;
    }
 
    public static string GetEnglish(string value)
    {
        foreach (var kv in _dictory)
        {
            if (kv.Value == value)
            {
                return kv.Key;
            }
        }
        Console.WriteLine("字典没有找到对应字符");
        return null;
    }
 
}
 
 
/// <summary>
/// 定义AbstractExpression接口
/// </summary>
public interface IExpressions
{
    void Interpret(StringBuilder sb);
}
 
/// <summary>
/// 英文转中文
/// </summary>
public class EnglishWordExpression : IExpressions
{
    private string Value;
 
    public EnglishWordExpression(string value)
    {
        Value = value;
    }
 
    public void Interpret(StringBuilder sb)
    {
        sb.Append(ChineseToEnglishDict.GetChinese(Value.ToLower()));
    }
}
 
/// <summary>
/// 中文转英文
/// </summary>
public class ChineseWordExpression : IExpressions
{
    private string Value;
 
    public ChineseWordExpression(string value)
    {
        Value = value;
    }
 
    public void Interpret(StringBuilder sb)
    {
        sb.Append(ChineseToEnglishDict.GetEnglish(Value.ToLower()));
    }
}
 
public static class Translators
{
    public static string EnglishToChinsesTranslator(string sentense)
    {
        StringBuilder sb=new StringBuilder();
        List<IExpressions> expressions = new List<IExpressions>();
       expressions.Add(new EnglishWordExpression(sentense));
 
        foreach (IExpressions e in expressions)
        {
            e.Interpret(sb);
        }
        return sb.ToString();
    }
 
    public static string ChinsesToEnglishTranslator(string sentense)
    {
        StringBuilder sb = new StringBuilder();
        List<IExpressions> expressions = new List<IExpressions>();
        expressions.Add(new ChineseWordExpression(sentense));
 
        foreach (IExpressions e in expressions)
        {
            e.Interpret(sb);
        }
        return sb.ToString();
    }
}

    首先实现一个ChineseToEnglishDict 中英文翻译字典类， 里面存放一个字典，存放我们的中英文字典，为了方便，我们也在里面把字典的内容填充好， 其实正确的做法是做两个 中英文的静态表存起来，分别从两个表取。然后里面还有两个方法 中文转英文和英文转中文， 就是从字典的key取value或者value取key。 接下来是一个IExpressions 虚拟翻译类，里面的Interpret虚拟方法我用了StringBuilder来代替示例代码的string，毕竟我们是要不断改写内容的。 然后 再写两个实体翻译类，一个中转英，一个英转中，就是分别调用 中英文翻译字典类的方法而已，最后 一个 静态翻译工具类，里面做的事就是我们在示例代码的实现类似，把重复使用的封装起来，看起来更简洁。好，现在看实现代码：

string english1 = "skills";
         string chinese1 = Translators.EnglishToChinsesTranslator(english1);
         Console.WriteLine(chinese1);
 
         string chinese2 = "好友";
         string english2 = Translators.ChinsesToEnglishTranslator(chinese2);
         Console.WriteLine(english2);

   这里实现代码是不是比示例更加简便了，传入一个需要翻译的字，然后在接收，输出。一气呵成。我们运行下看看结果：

 

   Interpreter 解释器模式的介绍就是以上内容，我们最后再来总结下，解释器模式属于行为模式，Gof是这样定义的：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解 释语言中的句子。
　　解释器模式需要解决的是，如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子 。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。