24_解释器模式

解释器模式是一种行为设计模式，它通过定义一个语言的文法规则，并且根据规则解释和执行对应的语言表达式。

在解释器模式中，通过定义抽象表达式（Abstract Expression）和具体表达式（Concrete Expression）来表示语言中的各种表达式。抽象表达式定义了表达式的解释方法，而具体表达式则实现了解释方法。

解释器模式包含以下几个角色：

1. 抽象表达式（Abstract Expression）：定义了表达式解释方法的接口。

2. 终结符表达式（Terminal Expression）：实现了解释方法，表示语言中的终结符表达式。

3. 非终结符表达式（Non-terminal Expression）：实现了解释方法，表示语言中的非终结符表达式。

4. 环境（Context）：包含了解释器需要的信息，负责存储和传递变量的值等。

解释器模式的工作流程如下：

1. 定义语言的文法规则，并将每个规则抽象成一个抽象表达式。

2. 实现具体表达式，来表示语言中的各种表达式。

3. 根据具体情况，创建具体表达式的实例，并将其组合成一个解释器树。

4. 调用解释器树的解释方法，对语言表达式进行解释和执行。

解释器模式的优点包括：

1. 可扩展性好，可以动态地添加新的表达式。

2. 可以灵活地改变文法规则和解释方法。

3. 可以方便地实现对语言表达式的解释和执行。

解释器模式适用于以下情况：

1. 有一个简单的语言，需要解释和执行其中的表达式。

2. 表达式的数量和复杂度有限，且经常需要进行修改和扩展。

总之，解释器模式是一种通过定义文法规则来解释和执行语言表达式的设计模式。它可以灵活地对语言进行解释和执行，适用于处理简单的、数量有限的语言表达式。

 

案例场景：

指令：
方向：up=向上，down=向下，left=向左，right=向右
模式：move=移动，run=快速移动
距离：实际值，不解释

表达式：string expression="up move 100 and down run 200 and left run 300";
指令格式：方向 运动模式 距离值

 

Abstract Expression

public abstract class ExpressionBase
    {
        public abstract string Interpret();
    }

 

 Terminal Expression

/// <summary>
    /// 方向模式的解释器表达式
    /// </summary>
    public class DirectionExpression : ExpressionBase
    {
        private string content;

        public DirectionExpression(string content)
        {
            this.content = content;
        }

        public override string Interpret()
        {
            switch (content)
            {
                case "up":
                    return "向上";
                    break;
                case "down":
                    return "向下";
                    break;
                case "left":
                    return "向左";
                    break;
                case "right":
                    return "向右";
                    break;
                default:
                    return "方向错误";
                    break;
            }
        }
    }

/// <summary>
    /// 运动模式的解释器表达式
    /// </summary>
    public class ModeExpression : ExpressionBase
    {
        private string content;

        public ModeExpression(string content)
        {
            this.content = content;
        }
        public override string Interpret()
        {
             if(this.content=="move")
            {
                return "移动";
            }
             else if(content=="run")
            {
                return "快速移动";
            }
             else
            {
                return "模式错误";
            }
        }
    }

/// <summary>
    /// 距离表达式
    /// </summary>
    public class DistanceExpression : ExpressionBase
    {
        private string content;

        public DistanceExpression(string content)
        {
            this.content = content;
        }
        public override string Interpret()
        {
            return content;
        }
    }

 

/// <summary>
    /// 终结符表达式
    /// </summary>
    public class TerminalExpression: ExpressionBase
    {
        private ExpressionBase direction, mode, distance;

        public TerminalExpression(ExpressionBase direction, ExpressionBase mode, ExpressionBase distance)
        {
            this.direction = direction;
            this.mode = mode;
            this.distance = distance;
        }

        public override string Interpret()
        {
            return string.Concat(direction.Interpret(), mode.Interpret(), distance.Interpret());
        }
    }

 

 Non-terminal Expression

/// <summary>
    /// 非终结符表达式
    /// </summary>
    public class NonTerminalExpression : ExpressionBase
    {
        private ExpressionBase left,right;

        public NonTerminalExpression(ExpressionBase left, ExpressionBase right)
        {
            this.left = left;
            this.right = right;
        }   

        public override string Interpret()
        {
            return $"{left.Interpret()}  然后  {right.Interpret()}";
        }
    }

 

Context

public class Context
    {
        private Stack<ExpressionBase> stack=new Stack<ExpressionBase>();
        private ExpressionBase direction, mode, distance, all;
        public void Execute(string content)
        {
            string[] array = content.Split(' ');
            for(int i=0;i<array.Length;i++)
            {
                if (array[i]=="and")
                {
                    ExpressionBase left=stack.Pop();
                    direction = new DirectionExpression(array[++i]);
                    mode = new ModeExpression(array[++i]);
                    distance = new DistanceExpression(array[++i]);
                    ExpressionBase right=new TerminalExpression(direction, mode, distance);
                    ExpressionBase end = new NonTerminalExpression(left, right);
                    stack.Push(end);
                }
                else
                {
                    direction= new DirectionExpression(array[i]);
                    mode = new ModeExpression(array[++i]);
                    distance = new DistanceExpression(array[++i]);
                    ExpressionBase end =new TerminalExpression(direction, mode, distance);
                    stack.Push(end);
                }
            }
            all=stack.Pop();
        }

        public string InterpretAll()
        {
            return all.Interpret();
        }
    }

 

调用

 internal class Client
    {
        public void Start()
        {
            Context context = new Context();
            string expression = "up move 100 and down run 200 and left run 300";
            context.Execute(expression);
            string result = context.InterpretAll();
            Console.WriteLine(result);
        }
    }

 static void Main(string[] args)
        {
            new Client().Start();
            Console.ReadKey();
            Console.WriteLine("Hello, World!");
        }