CSharpScript: Dynamic script parameter names

Question

I'm trying to use Roslyn to execute C# code that is defined by the user at runtime, similar to this example:

public class Globals
{
    public int X;
    public int Y;
}
var globals = new Globals { X = 1, Y = 2 };
Console.WriteLine(await CSharpScript.EvaluateAsync<int>("X+Y", globals: globals));

Example copied from here

My problem is that the variable names used in the script are unknown at compile time. In other words, I don't know what member-names I should use for my globals class and how many members (script-parameters) there will be.

I tried to use ExpandoObject to solve the problem but couldn't get it to work. Is ExpandoObject supposed to work in this context? Are there other ways to solve the problem?

Update

For my use case, the best solution is probably to use System.Linq.Dynamic:

//Expression typed in by the user at runtime
string Exp = @"A + B > C";

//The number of variables and their names are given elsewhere,
//so the parameter-array doesn't need to be hardcoded like in this example.
var e = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] 
{
    Expression.Parameter(typeof(double), "A"),
    Expression.Parameter(typeof(double), "B"),
    Expression.Parameter(typeof(double), "C")
}, 
null, Exp);

var Lambda = e.Compile();

//Fake some updates...
foreach (var i in Enumerable.Range(0,10))
{
    Console.WriteLine(Lambda.DynamicInvoke(i, 3, 10));
}

Answer 1

If you can retrieve at runtime all member names, their count and their values that were passed from input you can generate execution code at runtime and evaluate it. As a simple example of execution code you can generate variable declarations for all input values and then sum all of them:

// here you should put retrieved member names and their values. Just  for example, currently here exist a couple of args
var variablesAndValues = new Dictionary<string, object> { ["arg_1"] = 5, ["arg_2"] = 6, ["arg_3"] = 7 };

// and you should create an execution code looks like this:
// var arg_1 = value_1;
// ..
// var arg_n = value_n;
// arg_1 + .. + arg_n
StringBuilder builder = new StringBuilder();
foreach (var item in variablesAndValues)
{
    builder.Append("var ").Append(item.Key).Append(" = ").Append(item.Value).AppendLine(";");
}

var variablesCount = variablesAndValues.Count;
foreach (var item in variablesAndValues.Keys)
{
    builder.Append(item);
    if (--variablesCount > 0)
    {
        builder.Append(" + ");
    }
}

var scriptState = CSharpScript.RunAsync(builder.ToString()).Result;
var result = scriptState.ReturnValue;

Be careful, this example assumes that the all value types has sum_operation and them are known by default script options, else you will receive compile error when try to execute the code.

Upd.

If your cases are performance critically you may create a script that will sum all input arguments and then run this script repeatedly when you need it.

public class Globals
{
    public int[] Args;
}
...

// create script that sum all input arguments
var script = CSharpScript.Create(@"var result = 0;
foreach (var item in Args)
{
    result += item;
}
return result; ", globalsType: typeof(Globals));

// run it at twice on the user values that were received before
// also you can reuse an array, but anyway
var res1 = script.RunAsync(new Globals { Args = new[] { 5, 6, 7 } }).Result.ReturnValue;
var res2 = script.RunAsync(new Globals { Args = new[] { 7, 8, 9, 10} }).Result.ReturnValue;

This approach ignore in the script code the input variable names from an user, and seems that it doesn't matter in your cases.