模式的定义与特点

解释器模式（Interperter Pattern），给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。

模式的优点

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

模式的缺点

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

using DesignPattern.InterpreterPattern;
using System;

namespace DesignPattern
{
    internal class Program
    {
        static void Main(string[] args)
        {
            InterpreterHelper();
        }

        #region Pattern - Interpreter
        static void InterpreterHelper()
        {
            Interpreter _root1 = new CheckContentsExistence("Root1");
            Interpreter _root2 = new CheckContentsExistence("Root1");
            Interpreter _orExpr1 = new OrExpression(_root1, _root2);
            Console.WriteLine($"root 存在么：{_orExpr1.Interpret("root")}");

            Console.WriteLine();

            Interpreter _shanshan = new CheckContentsExistence("Shanshan");
            Interpreter _pig = new CheckContentsExistence("pig");
            Interpreter _isExpr2 = new AndExpression(_shanshan, _pig);
            Console.WriteLine($"Shanshan is a little pig? {_isExpr2.Interpret("pig Shanshan")}");
            Console.ReadLine();
        }
        #endregion


    }
}

//======================================================================================

namespace DesignPattern.InterpreterPattern
{
    /// <summary>
    /// 解释器接口
    /// </summary>
    public interface Interpreter
    {
        /// <summary>
        /// 解释器
        /// </summary>
        /// <param name="context">具体内容</param>
        /// <returns></returns>
        bool Interpret(string context);
    }

    /// <summary>
    /// 解释具体内容是否存在该元素中
    /// </summary>
    public class CheckContentsExistence : Interpreter
    {
        private string m_data;

        public CheckContentsExistence(string data)
        {
            this.m_data = data;
        }

        public bool Interpret(string context)
        {
            if (context.Contains(m_data))
            {
                return true;
            }
            return false;
        }
    }

    /// <summary>
    /// 或运算
    /// </summary>
    public class OrExpression : Interpreter
    {
        private Interpreter m_expr1 = null;
        private Interpreter m_expr2 = null;

        public OrExpression(Interpreter expression1, Interpreter expression2)
        {
            this.m_expr1 = expression1;
            this.m_expr2 = expression2;
        }

        public bool Interpret(string context)
        {
            return m_expr1.Interpret(context) || m_expr2.Interpret(context);
        }
    }

    /// <summary>
    /// 和运算
    /// </summary>
    public class AndExpression : Interpreter
    {
        private Interpreter m_expr1 = null;
        private Interpreter m_expr2 = null;

        public AndExpression(Interpreter expression1, Interpreter expression2)
        {
            this.m_expr1 = expression1;
            this.m_expr2 = expression2;
        }

        public bool Interpret(string context)
        {
            return m_expr1.Interpret(context) && m_expr2.Interpret(context);
        }
    }
}