设计模式--解释器模式

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