设计模式-行为型-解释器模式

解释器模式（Interpreter）：

　　从名称上来看看这个模式，个人的最初理解“解释器”和Google的中英翻译功能类似。如果有一天你去国外旅游去了，比如去美国吧，美国人是讲英语的，我们是讲汉语的，如果英语听不懂，讲不好，估计沟通就完蛋了，不能沟通，估计玩的就很难尽兴了，因为有很多景点的解说你可能不明白（没有中文翻译的情况下，一般情况会有的）。所以我们需要一个软件，可以把中英文互译，那彼此就可以更好的理解对方的意思，我感觉翻译软件也可以称得上是解释器，把你不懂的解释成你能理解的。我们写代码，需要编译器把我们写的代码编译成机器可以理解的机器语言，从这方面来讲，C#的编译器也是一种解释器。

解释器模式的角色：

　　 

　　1）抽象解释器（AbstractExpression）：定义解释器的接口，约定解释器的解释操作。其中的Interpret接口，正如其名字那样，它是专门用来解释该解释器所要实现的功能。

　　2）终结符表达式（TermialExpression）：实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。

　　3）非终结符表达式（NonterminalExpression）：文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+”就是非终结符，解析“+”的解释器就是一个非终结符表达式。

　　4）环境角色（Context）：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

　　我们演示一个判断且或的例子。 

public abstract class AbstractExpression
{
    public abstract bool Interpret(string context);
}

public class TerminalExpression : AbstractExpression
{
    private string data;

    public TerminalExpression(string data)
    {
        this.data = data;
    }

    public override bool Interpret(string context)
    {
        return data.Contains(context);
    }
}

public class OrExpression : AbstractExpression
{
    private AbstractExpression expr1 = null;
    private AbstractExpression expr2 = null;

    public OrExpression(AbstractExpression expr1, AbstractExpression expr2)
    {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    public override bool Interpret(string context)
    {
        return expr1.Interpret(context) || expr2.Interpret(context);
    }
}

public class AndExpression : AbstractExpression
{
    private AbstractExpression expr1 = null;
    private AbstractExpression expr2 = null;

    public AndExpression(AbstractExpression expr1, AbstractExpression expr2)
    {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    public override bool Interpret(string context)
    {
        return expr1.Interpret(context) || expr2.Interpret(context);
    }
}

public class Program
{
    //规则：Robert 和 John 是男性
    public static AbstractExpression GetMaleExpression()
    {
        AbstractExpression robert = new TerminalExpression("Robert");
        AbstractExpression john = new TerminalExpression("John");
        return new OrExpression(robert, john);
    }

    //规则：Julie 是一个已婚的女性
    public static AbstractExpression GetMarriedWomanExpression()
    {
        AbstractExpression julie = new TerminalExpression("Julie");
        AbstractExpression married = new TerminalExpression("Married");
        return new AndExpression(julie, married);
    }

    public static void Main(string[] args)
    {
        AbstractExpression isMale = GetMaleExpression();
        AbstractExpression isMarriedWoman = GetMarriedWomanExpression();

        Console.WriteLine($"John is male? {isMale.Interpret("John")}");
        Console.WriteLine($"Julie is a married women? {isMarriedWoman.Interpret("Married Julie")}");
    }
}

　　这里我们可以得出：解释器模式有很好的扩展模式，或此时我们希望能够找到一位男士已婚，我们只需要再写一个非终结符表达式即可，易于扩展。我们再来看下面这个例子。

// 抽象表达式
public abstract class Expression
{
    protected Dictionary<string, int> table = new Dictionary<string, int>(9);

    protected 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 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 - 1);
            }
        }
    }

    public abstract string GetPostFix();

    public abstract int Multiplier();

    //这个可以通用，但是对于个位数字例外，所以用虚方法
    public virtual int GetLength()
    {
        return this.GetPostFix().Length + 1;
    }
}

//个位表达式
public sealed class GeExpression : Expression
{
    public override string GetPostFix()
    {
        return "";
    }

    public override int Multiplier()
    {
        return 1;
    }

    public override int GetLength()
    {
        return 1;
    }
}

//十位表达式
public sealed class ShiExpression : Expression
{
    public override string GetPostFix()
    {
        return "十";
    }

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

//百位表达式
public sealed class BaiExpression : Expression
{
    public override string GetPostFix()
    {
        return "百";
    }

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

//千位表达式
public sealed class QianExpression : Expression
{
    public override string GetPostFix()
    {
        return "千";
    }

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

//万位表达式
public sealed 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;
        }

        ArrayList tree = new ArrayList();

        tree.Add(new GeExpression());
        tree.Add(new ShiExpression());
        tree.Add(new BaiExpression());
        tree.Add(new QianExpression());

        foreach (string key in table.Keys)
        {
            if (context.Statement.EndsWith(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.Interpreter(context);
                }
                context.Data = temp + context.Data * this.Multiplier();
            }
        }
    }
}

//亿位表达式
public sealed class YiExpression : Expression
{
    public override string GetPostFix()
    {
        return "亿";
    }

    public override int Multiplier()
    {
        return 100000000;
    }

    public override void Interpreter(Context context)
    {
        ArrayList tree = new ArrayList();

        tree.Add(new GeExpression());
        tree.Add(new ShiExpression());
        tree.Add(new BaiExpression());
        tree.Add(new QianExpression());

        foreach (string key in table.Keys)
        {
            if (context.Statement.EndsWith(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.Interpreter(context);
                }
                context.Data = temp + context.Data * this.Multiplier();
            }
        }
    }
}

//环境上下文
public sealed class Context
{
    private string _statement;
    private int _data;

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

    public string Statement
    {
        get { return this._statement; }
        set { this._statement = value; }
    }

    public int Data
    {
        get { return this._data; }
        set { this._data = value; }
    }
}

internal class Program
{
    private static void Main(string[] args)
    {
        string roman = "五亿七千三百零二万六千四百五十二";
        //分解：((五)亿)((七千)(三百)(零)(二)万)
        //((六千)(四百)(五十)(二))

        Context context = new Context(roman);
        List<Expression> tree = new List<Expression>();
        tree.Add(new GeExpression());
        tree.Add(new ShiExpression());
        tree.Add(new BaiExpression());
        tree.Add(new QianExpression());
        tree.Add(new WanExpression());
        tree.Add(new YiExpression());

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

        Console.Write(context.Data);
    }
}

　　看完之后是不是想骂一句fuck，我只是想要简单的转换一下，却需要写这么一大坨，显然不符合我们的心意。

解释器模式的优缺点：

　　优点：

　　　　1）易于改变和扩展文法。

　　　　2）每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。

　　　　3）实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。

　　　　4）增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合“开闭原则”。

　　缺点：

　　　　1）对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。

　　　　2）执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

解释器模式的应用场景：

　　1）当一个语言需要解释执行，并可以将该语言中的句子表示为一个抽象语法树的时候，可以考虑使用解释器模式（如XML文档解释、正则表达式等领域）。

　　2）一些重复出现的问题可以用一种简单的语言来进行表达。

　　3）一个语言的文法较为简单.

　　4）当执行效率不是关键和主要关心的问题时可考虑解释器模式（注：高效的解释器通常不是通过直接解释抽象语法树来实现的，而是需要将它们转换成其他形式，使用解释器模式的执行效率并不高。）

参考：https://www.cnblogs.com/PatrickLiu/p/8242238.html