23.解释器模式（Interpreter Pattern）

解释器模式

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

意图：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。

优点：

• 可扩展性比较好，灵活。
• 增加了新的解释表达式的方式。
• 易于实现简单文法。

缺点：

• 可利用场景比较少。
• 对于复杂的文法比较难维护。
• 解释器模式会引起类膨胀。
• 解释器模式采用递归调用方法。

类图如下。

完整代码如下。

using System;

namespace _23_InterpreterPattern
{
     
    /// 

    /// 解释器模式
    /// 
    class Program
    {
     
        static void Main(string[] args)
        {
     
            IExpression isMale = GetMaleExpression();
            IExpression isMarriedWoman = GetMarriedWomanExpression();

            Console.WriteLine("John is male? " + isMale.Interpret("John"));
            Console.WriteLine("Julie is a married women? "
            + isMarriedWoman.Interpret("Married Julie"));
        }
        //规则：Robert 和 John 是男性
        public static IExpression GetMaleExpression()
        {
      
            IExpression robert = new TerminalExpression("Robert");
            IExpression john = new TerminalExpression("John");
            return new OrExpression(robert, john);
        }

        //规则：Julie 是一个已婚的女性
        public static IExpression GetMarriedWomanExpression()
        {
     
            IExpression julie = new TerminalExpression("Julie");
            IExpression married = new TerminalExpression("Married");
            return new AndExpression(julie, married);
        }
    }
    public interface IExpression
    {
     
        public bool Interpret(string context);
    }
    public class TerminalExpression : IExpression
    {
     
        private string _date;
        public TerminalExpression(string date)
        {
     
            _date = date;
        }
        public bool Interpret(string context)
        {
     
            if (context.Contains(_date))
                return true;
            return false;
        }
    }
    public class OrExpression : IExpression
    {
     
        private IExpression _expr1 = null;
        private IExpression _expr2 = null;
        public OrExpression(IExpression expr1, IExpression expr2)
        {
     
            _expr1 = expr1;
            _expr2 = expr2;
        }

        public bool Interpret(string context)
        {
     
            return _expr1.Interpret(context) || _expr2.Interpret(context);
        }
    }
    public class AndExpression : IExpression
    {
     
        private IExpression _expr1 = null;
        private IExpression _expr2 = null;
        public AndExpression(IExpression expr1, IExpression expr2)
        {
     
            _expr1 = expr1;
            _expr2 = expr2;
        }

        public bool Interpret(string context)
        {
     
            return _expr1.Interpret(context) || _expr2.Interpret(context);
        }
    }

}