Інтерпретатор (шаблон проєктування)

// глобальні дані доступні усім виразам
class Context
{
	private readonly Dictionary<string, object> _variables = new Dictionary<string, object>();

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

	public object GetVariable(string name)
	{
		return _variables[name];
	}
}

// базовий клас для виразів
abstract class ExpressionBase
{
	public abstract object Interpret(Context context);
}

// об'єктно орієнтоване предсталення мови
class IntegerExpression : ExpressionBase
{
	private int _value;

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

	public override object Interpret(Context context)
	{
		return _value;
	}
}

class VariableExpression : ExpressionBase
{
	private readonly string _name;

	public VariableExpression(string name)
	{
		_name = name;
	}

	public override object Interpret(Context context)
	{
		return context.GetVariable(_name);
	}
}

class GreaterThanExpression : ExpressionBase
{
	private readonly VariableExpression _variableExp;
	private readonly IntegerExpression _integerExp;

	public GreaterThanExpression(VariableExpression variableExp, IntegerExpression integerExp)
	{
		_variableExp = variableExp;
		_integerExp = integerExp;
	}

	public override object Interpret(Context context)
	{
		var variable = (int)_variableExp.Interpret(context);
		var number = (int)_integerExp.Interpret(context);

		return variable > number;
	}
}

class SelectExpression : ExpressionBase
{
	private readonly ExpressionBase _dataExp;

	public SelectExpression(ExpressionBase dataExp)
	{
		_dataExp = dataExp;
	}

	public override object Interpret(Context context)
	{
		if (_dataExp is IntegerExpression intExp)
		{
			var value = (int)intExp.Interpret(context);

			return new int[] { value };
		}

		if (_dataExp is VariableExpression varExp)
		{
			return varExp.Interpret(context) as int[];
		}

		throw new InvalidOperationException("Invalid value type for Select expression");
	}
}

class FilterExpression : ExpressionBase
{
	private readonly ExpressionBase _dataExp;
	private readonly ExpressionBase _conditionExp;
	private readonly string _tempVariableName;

	public FilterExpression(ExpressionBase dataExp, ExpressionBase conditionExp, string tempVariableName)
	{
		_dataExp = dataExp;
		_conditionExp = conditionExp;
		_tempVariableName = tempVariableName;
	}

	public override object Interpret(Context context)
	{
		var data = _dataExp.Interpret(context) as int[];

		var result = new List<int>();
		foreach (var item in data)
		{
			context.SetVariable(_tempVariableName, item);

			var isSatisfied = (bool)_conditionExp.Interpret(context);

			if (isSatisfied)
			{
				result.Add(item);
			}
		}

		return result.ToArray();
	}
}

// не є частиною шаблону, та спрощує побудову дерева виразів
class Parser
{
	public ExpressionBase Parse(string expression)
	{
		var tokens = expression.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);

		return ParseNextExpression(tokens);
	}

	private ExpressionBase ParseNextExpression(IEnumerable<string> tokens)
	{
		var token = tokens.First();

		if (IsNumber(token))
		{
			return new IntegerExpression(int.Parse(token));
		}
		if (token.StartsWith("{") && token.EndsWith("}"))
		{
			var variableName = token.Trim(new char[] { '{', '}' });

			return new VariableExpression(variableName);
		}
		if (token == "greater")
		{
			var variableExp = ParseNextExpression(tokens.Skip(1)) as VariableExpression;
			var integerExp = ParseNextExpression(tokens.Skip(3)) as IntegerExpression;

			return new GreaterThanExpression(variableExp, integerExp);
		}
		if (token == "select")
		{
			ExpressionBase exp = ParseNextExpression(tokens.Skip(1));

			return new SelectExpression(exp);
		}
		if (token == "filter")
		{
			ExpressionBase dataExp = ParseNextExpression(tokens.Skip(2));
			ExpressionBase conditionExp = ParseNextExpression(tokens.Skip(4));
			string tempVariableName = tokens.ElementAt(6).Trim(new char[] { '{', '}' });

			return new FilterExpression(dataExp, conditionExp, tempVariableName);
		}
		if (token == "|")
		{
			return ParseNextExpression(tokens.Skip(1));
		}

		if (token == "than")
		{
			return ParseNextExpression(tokens.Skip(1));
		}

		throw new InvalidOperationException($"Invalid token {token}");
	}

	private bool IsNumber(string token)
	{
		return int.TryParse(token, out int _);
	}
}

class Program
{
	public static void Main()
	{
		// нехай необхідно обрахувати значення виразу
		var expression = @"
	        filter
				| select {arr}
				| greater {x} than 2";

		var parameter = "arr";
		var parameterValue = new int[] { 1, 2, 3, 4, 5 };

		var result = Evaluate(expression, parameter, parameterValue);

		result.ToList().ForEach(Console.WriteLine);
	}
	public static int[] Evaluate(string expression, string parameterName, object parameterValue)
	{
		// динамічна побудова дерева виразів
		var parser = new Parser();
		var expressionTree = parser.Parse(expression);

		// статична побудова дерева виразів
		var staticExpressionTree = new FilterExpression(
			new SelectExpression(new VariableExpression("arr")),
			new GreaterThanExpression(new VariableExpression("x"), new IntegerExpression(2)),
			tempVariableName: "x");

		// обрахунок виразу
		var context = new Context();
		context.SetVariable(parameterName, parameterValue);

		return expressionTree.Interpret(context) as int[];
	}
}