如何使用动态对象作为 lambda 表达式的输入？

Question

I want to store expression in a database in order to maintain a rule engine. The expressions are in the form of this example:

Expression<Func<MyTerm, bool>> expression = t => t.MyProperty == SomeValue;

The problem I am facing is that I have to create MyTerm at runtime. In order to still be able to use MyTerm as a parameter for a lambda expression, I implemented a solution with ExpandoObject, like so:

public class MyTerm
{
    ExpandoObject ParameterSet;

    public void AddParameter(string name, object value)
    {
        IDictionary<string, object> dictionary = ParameterSet as IDictionary<string, object>;
        if (dictionary.ContainsKey(name))
        {
            dictionary[name] = value;
        }
        else
        {
            dictionary.Add(name, value);
        }
    }

    public string GetString(string name)
    {
        IDictionary<string, object> dictionary = ParameterSet as IDictionary<string, object>;
        if (dictionary.ContainsKey(name))
        {
            return (string)dictionary[name];
        }
        throw new KeyNotFoundException("Term does not contain parameter {name}.");
    }

The thing is, I gain the advantage of being able to add parameters at runtime to MyTerm, but I have to specify the return type for each getter, instead of being able to use the syntax above:

t.MyProperty

Is there a way to use dynamic objects as input for lambda expressions or are there ways to write an extension method for classes like this in order to return an object and not a specific type? I am able to compile expressions like so:

public static Func<MyTerm, bool> Compile(string body)
{
    ParameterExpression term = Expression.Parameter(typeof(MyTerm), typeof(MyTerm).Name);
    LambdaExpression exp = DynamicExpressionParser.ParseLambda(new[] { term }, typeof(bool), body);
    return (Func<DynamicTerm, bool>)exp.Compile();
}

static void Main(string[] args)
{
    MyTerm term = new MyTerm();
    term.AddParameter("SomeParameter", "SomeValue");

    Func<MyTerm, bool> IsGreaterThanSomeParameter = Compile("MyTerm.GetString(\"SomeParameter\")== SomeValue);

    bool result = IsGreaterThanSomeParameter(term);

    Console.WriteLine(result);
    Console.ReadLine();
}

I want to store lambda expressions that are independent from a specific implementation, so if another service tries to compile these expressions back to a function, the syntax should be usable out of the box. Without any workaroung getters. Thank you in advance.

Answer 1

It turns out that if your object has an indexer on it, System.Linq.Dynamic will try and call it if it doesn't find a matching property.

public class DynamicTerm
{
    private readonly Dictionary<string, object> store = new Dictionary<string, object>();

    public void Set(string key, object value) => store[key] = value;
    public object this[string key] => store[key];
}

public static void Main()
{
    string body = "Term.SomeProperty == \"foo\"";
    ParameterExpression termExpr = Expression.Parameter(typeof(DynamicTerm), "Term");
    var exp = DynamicExpressionParser.ParseLambda(new[] { termExpr }, typeof(bool), body);
    var compiled = (Func<DynamicTerm, bool>)exp.Compile();

    var term = new DynamicTerm();
    term.Set("SomeProperty", "foo");

    Console.WriteLine(compiled(term));
}

I can't find a way of returning typed data (it converts both sides to object): it works with strings however. Perhaps it's a starting point.