A way to dynamically compile and execute any expression having the list of parameters.

[Rotabor]

I was troubled to compile an expression dynamically when it's not possible to hardcode expression's delegate. So, I want to allow the user to define the list of parameters and the expression to calculate. The compiled expression should be stored for later invocation. Here is the way how I solved this task.

// .Net 8.0
using System.Linq.Expressions;
using DynamicExpresso;

namespace ConsoleApp3;

internal class SimpleParameter {
    public string Type { get; set; }
    public string Name { get; set; }
    public object? Value { get; set; }
    public SimpleParameter(string type, string name, object? value) {
        Type = type; Name = name; Value = value;
    }
}

internal class AnyParametersDemo {

    Delegate? _expression;
    List<SimpleParameter> _expars;

    static LambdaExpression GetLambdaExpression(Expression expression, Type delegateType, Parameter[] parameters) {
        Type[] genericArguments = delegateType.GetGenericArguments();
        genericArguments[^1] = expression.Type;
        return Expression.Lambda(delegateType.GetGenericTypeDefinition().MakeGenericType(genericArguments),
            expression, parameters.Select((Parameter p) => p.Expression).ToArray());
    }

    public AnyParametersDemo(string exprns, SimpleParameter[] calcpars) {
        var interpreter = new Interpreter();
        _expars = new();
        var detectedIdentifiers = interpreter.DetectIdentifiers(exprns);
        var i = detectedIdentifiers.UnknownIdentifiers.Count();
        var parameters = new Parameter[i]; var j = 0;
        foreach (var p in detectedIdentifiers.UnknownIdentifiers) {
            var par = Array.Find(calcpars, f => f.Name == p);;
            if (par is null) throw new Exception($"Parameter {p} not found");
            _expars.Add(par);
            parameters[j++] = new Parameter(p, par.Type == "String" ? "" : Activator.CreateInstance(Type.GetType("System." + par.Type)));
        }
        var expression = interpreter.Parse(exprns, parameters).Expression;
        var list = _expars.Select(s => s.Type).ToList(); list.Add("Object");
        var array = list.Select(s => Type.GetType("System." + s)).ToArray();
        var delegateType = Expression.GetFuncType(array);
        var le = GetLambdaExpression(expression, delegateType, parameters);
        _expression = le.Compile();
    }

    public object? Calculate() => _expression?.DynamicInvoke(_expars.Select(s => s.Value).ToArray());
}

internal class DynamicExpressoDemo{

    static void Main() {
        try {
            SimpleParameter[] parameters = [
                new SimpleParameter("Double", "cvb", 1),
                new SimpleParameter("Double", "erg", 2.7183),
                new SimpleParameter("String", "yuiyu", "Hello"),
                new SimpleParameter("Double", "mnbn", 27.3),
                new SimpleParameter("Double", "sds", 3.1416),
                new SimpleParameter("Double", "yuyt", 32.1),
                new SimpleParameter("Int32", "zxc", 2),
            ];
            var expression = "sds + erg";
            Console.WriteLine("Expression --> " + expression);
            Console.WriteLine("Result --> " + new AnyParametersDemo(expression, parameters).Calculate());
            Console.WriteLine(new String('-', 80));
            expression = "yuiyu + \", World! \" + (mnbn + yuyt) / zxc";
            Console.WriteLine("Expression --> " + expression);
            Console.WriteLine("Result --> " + new AnyParametersDemo(expression, parameters).Calculate());
            Console.WriteLine(new String('-', 80));
        }
        catch (Exception ex) { Console.WriteLine(ex.Message); }
    }
}

Results:

Expression --> sds + erg
Result --> 5,8599
--------------------------------------------------------------------------------
Expression --> yuiyu + ", World! " + (mnbn + yuyt) / zxc
Result --> Hello, World! 29,700000000000003
--------------------------------------------------------------------------------

[davideicardi]

Maybe you can directly use Interpreter.Parse(...).Invoke(...) method? Or Interpreter.Eval?

[davideicardi]

you can store the output of Interpreter.Parse?

[Rotabor]

I tested the compiled expression vs "expr.Invoke(...)", where "expr = Interpreter.Parse(...)". The first one is about 3-5 times faster.

[asulwer]

@davideicardi sure can store the output. Parse is deprecated so i am using ParseAsDelegate, ParseAsExpression and Eval to accomplish similarly

[asulwer]

this uses Reflection, if you switch to Emit then its 10-20 times faster

[Rotabor]

@asulwer What is your suggestion so far?

[asulwer]

@Rotabor i created a Rules based system to build and store expressions.

a crappy version that i forked

i am working on an improved version (portion of code below for improved version). i slightly modified your code which is the Invoke method. Eval and Invoke accomplish the same thing.

public class Rule
{
    private Interpreter interpreter => new();

    [Key] public Guid Id { get; private set; } = Guid.NewGuid();
    public string Name { get; set; } = string.Empty;
    public bool IsActive { get; set; } = true;
    public string Expression { get; set; } = string.Empty;
    public IEnumerable<Parameter> Parameters { get; set; } = Enumerable.Empty<Parameter>();
    public IEnumerable<Rule> Rules { get; set; } = Enumerable.Empty<Rule>();

    public IEnumerable<T> ParseAsDelegate<T>()
    {
        foreach (var rule in Rules)
        {
            foreach (var del in rule.ParseAsDelegate<T>())
                yield return del;                
        }

        yield return interpreter.ParseAsDelegate<T>(Expression, (from Parameter p in Parameters select p.Name).ToArray());
    }
    public IEnumerable<Expression<T>> ParseAsExpression<T>()
    {
        foreach (var rule in Rules)
        {
            foreach (var del in rule.ParseAsExpression<T>())
                yield return del;
        }

        yield return interpreter.ParseAsExpression<T>(Expression, (from Parameter p in Parameters select p.Name).ToArray());
    }
    public IEnumerable<T> Eval<T>(params Parameter[] parameters)
    {
        foreach(var rule in Rules)
        {
            foreach (var del in rule.Eval<T>(parameters))
                yield return del;
        }

        yield return interpreter.Eval<T>(Expression, parameters);
    }        

    public IEnumerable<object> Invoke<T>(T t)
    {
        foreach (var rule in Rules)
        {
            foreach (var del in rule.Invoke(t))
                yield return del;
        }

        Parameter parameter = new Parameter(t!.GetType().Name, t!.GetType(), t);

        var exp = interpreter.Parse(Expression, parameter).Expression;
        Type[] ta = [ parameter.Type, typeof(object) ];
        var delegateType = System.Linq.Expressions.Expression.GetFuncType(ta);

        Type[] genericArguments = delegateType.GetGenericArguments();
        genericArguments[^1] = exp.Type;
        var le = System.Linq.Expressions.Expression.Lambda(delegateType.GetGenericTypeDefinition().MakeGenericType(genericArguments), exp, parameter.Expression);

        yield return le.Compile().DynamicInvoke(parameter)!;
    }
}

[Rotabor]

Thank you Aaaron, I'll attentively research your solution.

[asulwer]

i hope it helps you