设计模式--解释器模式

解释器模式是一种行为型设计模式，它定义了一种语言解释器的方式，用于解释特定的语言或符号。在该模式中，定义一个语法，用于解释特定的输入，并把这个语法表示为一个解释器。

使用解释器模式，我们可以定义自己的语法规则，并将它们转换成可执行代码或另一种形式的输出。该模式通常用于实现编程语言、表达式解析器和领域特定语言（DSL）等。它的好处在于可以非常容易地添加新的语法，并且可以根据需要进行修改。

以下是一个简单的使用解释器模式的C#示例：

代码语言：javascript复制

using System;
using System.Collections.Generic;

// 抽象表达式
public abstract class Expression 
{    
    public abstract int Interpret(Dictionary<string,int> variables);
}

// 变量表达式
public class VariableExpression : Expression
{
    private string _name;
    public VariableExpression(string name) 
    {
        _name = name;
    }

    public override int Interpret(Dictionary<string,int> variables) 
    {
        if (variables.ContainsKey(_name)) 
        {
            return variables[_name];
        }
        else 
        {
            throw new Exception("Variable not defined.");
        }
    }
}

// 常量表达式
public class ConstantExpression : Expression
{
    private int _value;

    public ConstantExpression(int value) 
    {
        _value = value;
    }

    public override int Interpret(Dictionary<string,int> variables) 
    {
        return _value;
    }
}

// 二元运算符表达式
public abstract class BinaryExpression : Expression 
{
    protected Expression _leftOperand;
    protected Expression _rightOperand;

    public BinaryExpression(Expression left, Expression right) 
    {
        _leftOperand = left;
        _rightOperand = right;
    }
}

// 加法表达式
public class AddExpression : BinaryExpression 
{
    public AddExpression(Expression left, Expression right) : base(left, right) 
    {
    }

    public override int Interpret(Dictionary<string,int> variables) 
    {
        return _leftOperand.Interpret(variables)   _rightOperand.Interpret(variables);
    }
}

// 减法表达式
public class SubtractExpression : BinaryExpression 
{
    public SubtractExpression(Expression left, Expression right) : base(left, right) 
    {
    }

    public override int Interpret(Dictionary<string,int> variables) 
    {
        return _leftOperand.Interpret(variables) - _rightOperand.Interpret(variables);
    }
}

// 上下文
public class Context 
{
    private Dictionary<string,int> _variables = new Dictionary<string,int>();

    public void SetVariable(string name, int value) 
    {
        _variables[name] = value;
    }

    public int GetVariable(string name) 
    {
        if (_variables.ContainsKey(name)) 
        {
            return _variables[name];
        }
        else 
        {
            throw new Exception("Variable not defined.");
        }
    }

    // 解释表达式
    public int Interpret(Expression expression) 
    {
        return expression.Interpret(_variables);
    }
}

class Program 
{
    static void Main() 
    {
        // 定义上下文
        var context = new Context();

        // 定义变量
        var x = new VariableExpression("x");
        var y = new VariableExpression("y");
        var z = new VariableExpression("z");

        // 定义常量
        var one = new ConstantExpression(1);
        var two = new ConstantExpression(2);
        var three = new ConstantExpression(3);

        // 定义表达式
        var expression1 = new AddExpression(new SubtractExpression(x,y), new AddExpression(one, two));
        var expression2 = new SubtractExpression(new AddExpression(x, y), new AddExpression(two, three));
        var expression3 = new AddExpression(new SubtractExpression(z, y), new SubtractExpression(x, one));

        // 设置变量值
        context.SetVariable("x", 10);
        context.SetVariable("y", 5);
        context.SetVariable("z", 2);

        // 解释表达式
        Console.WriteLine("Expression1 result: "   context.Interpret(expression1));
        Console.WriteLine("Expression2 result: "   context.Interpret(expression2));
        Console.WriteLine("Expression3 result: "   context.Interpret(expression3));
    }
}

在此示例中，我们定义了三种类型的表达式：变量表达式、常量表达式和二元运算符表达式。我们还定义了上下文类，用于存储变量的值，并调用解释器来解释表达式。 我们创建了三个不同的表达式，并使用上下文来存储变量的值并解释表达式。

.net

0 人点赞