Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Compile deserialized Expression using Serialize.Linq

I'm not able to find the way how to compile the deserialized Expression using Serialize.Linq. The accepted answer in "Compile Expression at runtime Using Serialize.Linq" doesn't work (part 2 below):

using System.Linq.Expressions;
using Serialize.Linq.Extensions;
using Serialize.Linq.Serializers;

namespace ConsoleApp3;

internal class Program {

    static void Main() {
        Expression<Func<double, double, double>> distanceCalc =
            (x, y) => Math.Sqrt(x * x + y * y);
        var xParameter = Expression.Parameter(typeof(double), "x");
        var yParameter = Expression.Parameter(typeof(double), "y");
        var xSquared = Expression.Multiply(xParameter, xParameter);
        var ySquared = Expression.Multiply(yParameter, yParameter);
        var sum = Expression.Add(xSquared, ySquared);
        var sqrtMethod = typeof(Math).GetMethod("Sqrt", new[] { typeof(double) }) ?? throw new InvalidOperationException("Math.Sqrt not found!");
        var distance = Expression.Call(sqrtMethod, sum);
        var distanceLambda = Expression.Lambda<Func<double, double, double>>(
            distance,
            xParameter,
            yParameter);

        var serializer = new ExpressionSerializer(new Serialize.Linq.Serializers.JsonSerializer());
        string serializedExpression = serializer.SerializeText(distanceLambda);

        // part 1 works
        var de1 = serializer.DeserializeText(serializedExpression).ToExpressionNode().ToExpression<Func<double, double, double>>();
        var espre1 = de1.Compile();
        Console.WriteLine(espre1(3, 4));

        // part 2 as per "Compile Expression at runtime Using Serialize.Linq" doesn't work
        var de2 = serializer.DeserializeText(serializedExpression) as LambdaExpression;
        var espre2 = de2.Compile();
        // Console.WriteLine(espre2(3, 4)); compiler error on espre2 "Method name expected"

        // part 3 another problem
        var de3 = serializer.DeserializeText(serializedExpression).ToExpressionNode().ToExpression<Func<double, double, double>>();
        var t3 = de3.GetType();
        var tm3 = t3.GetMethod("Compile", []);
        var espre3 = tm3.Invoke(de3, []); // expre3 shows "Internal error evaluating expression" in debug
        // Console.WriteLine(espre3(3, 4)); compiler error on espre3 "Method name expected"
    }
}

Of cause, part 1 is not the way because "ToExpression<Func<double, double, double>>()" can't be applied (unknown).

Also, please explain the problem in the part 3

Answer*

Given that you are trying to handle the general case where you aren't necessarily going to know the method signature, that leaves you with plain `LambdaExpression` compiling to `Delegate`.

Let's assume that you have the following:

* The function serialized as JSON.
* An object array of parameters to pass into the function.

The process is to deserialize the function to a `LambdaExpression`, compile it to `Delegate` and then call `Invoke`. Unfortunately `Delegate` doesn't allow direct invocation, but you can use the `Method` property to access the compiled method, then invoke that.

Something similar to this:

```csharp
static object? ExecuteSerializedFunction(string serializedFunction, object?[] parameters)
{
	ExpressionSerializer serializer = new(new JsonSerializer());
	LambdaExpression? expression = serializer.DeserializeText(serializedFunction)
		.ToExpressionNode()
		as LambdaExpression;
	
	// Compile to a Delegate with any signature
	Delegate? function = expression?.Compile();
	
	// Get the method to execute
	MethodInfo? method = funcion?.Method;
	
	// In my testing compilation adds a 'Capture' parameter - adjust as required.
	object?[] actualParameters = [null, ..parameters]

// Execute the method and return the result.
	// NB: There is no instance variable for the invocation.
	return method?.Invoke(null, actualParameters);
}
```

This is quite simplified, and there's a good chance there will be unexpected things in the required parameter list. I added an empty 'Capture' parameter in the code above, but you'll want to do a lot more than that. If you get the wrong parameter list, `Invoke` will throw an exception.

(Also, handle exceptions. This is just a minimal example.)

Edit Summary*

Cancel

".ToExpressionNode()" is extra and causes an error. Also ".Method.Invoke(null, [null, 3, 4 ])" looks more complex than ".DynamicInvoke(3, 4)"
– rotabor
Commented Apr 8, 2024 at 6:46
@rotabor DynamicInvoke may work for you, it may not. Try it and see. The parameters get boxed to object?[]? either way. And I copied part of your deserialize code because I don't use the library.
– Corey
Commented Apr 8, 2024 at 8:31

Add a comment |

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

Collectives™ on Stack Overflow

Compile deserialized Expression using Serialize.Linq

Answer*