Call a MethodCallExpression with dynamic number of parameters

c# expression-trees

Question

I must dial the following number:

public MethodCallExpression CreateLazyMethod(object instance, MethodBase foundMethodInfo)
{
    var orderedParameters = MethodParametersEvaluator.OrderParameters(foundMethodInfo.GetParameters());
    var paramExpressions = orderedParameters.Select(x => (Expression)Expression.Parameter(x.GetType())).ToArray();
    return Expression.Call((MethodInfo)foundMethodInfo, paramExpressions);
}

During run time, and determine the parameters the following

var callabel = CreateLazyMethod(instance, foundMethodInfo);
var runtimeEvaluatedParamsList=new object[]{1,654,};
callable.Invoke(runtimeEvaluatedParamsList);

Any suggestions?

1
0
10/28/2014 4:54:02 PM

Accepted Answer

It may be sent asobject[] and then utilize a certain item when creating a method.

Essentially for"Test Long String".Substring(5); The following code will produce this method:

object DynamicMethod(object[] params)
{
    return "Test Long String".Substring((int)params[0]);
}

The fact that the result and parameters are objects has the disadvantage of producing unnecessary boxing and unpacking processes; however, if you know the signature, you may create a generic implementation that uses specified types.

Code example

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

public class Program
{
    public static void Main(string[] args)
    {
        // test non static method with result
        string test = "Test String";
        MethodInfo method = typeof(string).GetMethod("Substring", BindingFlags.Public | BindingFlags.Instance, null, new Type[]{typeof(int)},null);
        Func<object[], object> lazyMethod = CreateLazyMethodWithResult(test, method);
        object result = lazyMethod(new object[] { 5 });
        Console.WriteLine(result);
        Console.WriteLine();

        // test static method with no result
        var staticMethod = typeof(Program).GetMethod("StaticMethod", BindingFlags.Static | BindingFlags.Public);
        var staticAction = CreateLazyStaticMethodWithNoResult(staticMethod);

        staticAction(new object[]{"Test message"});
        Console.WriteLine();

        //test static method with result
        var staticMethodWithResult = typeof(Program).GetMethod("StaticMethodWithResult", BindingFlags.Static | BindingFlags.Public);
        var staticActionWithResult = CreateLazyStaticMethodWithResult(staticMethodWithResult);

        Console.WriteLine(staticActionWithResult(new object[] { "Test message" }));
        Console.WriteLine();

        // sample with constructor
        var constructorCall = typeof(TestClass).GetConstructors().First();
        var constructorAction = GenerateLazyConstructorCall(constructorCall);

        var createdObject = constructorAction(new object[] { "Test message" });

        Console.WriteLine("Created type is " + createdObject.GetType().FullName);
    }

    //Test class
    public class TestClass
    {
        public TestClass(string message)
        {
            Console.WriteLine("----Constructor is called with message - " + message);
        }
    }

    public static void StaticMethod(string message)
    {
        Console.WriteLine("----Static method is called with " + message);
    }

    public static string StaticMethodWithResult(string message)
    {
        Console.WriteLine("----Static method with result is called with " + message);
        return "Hello from static method";
    }

    public static Func<object[], object> CreateLazyMethodWithResult(object instance, MethodInfo method)
    {
        ParameterExpression allParameters;
        var methodCall = GenerateCallExpression(instance, method, out allParameters);
        var lambda = Expression.Lambda<Func<object[], object>>(methodCall, allParameters);
        return lambda.Compile();
    }

    public static Action<object[]> CreateLazyMethodWithNoResult(object instance, MethodInfo method)
    {
        ParameterExpression allParameters;
        var methodCall = GenerateCallExpression(instance, method, out allParameters);
        var lambda = Expression.Lambda<Action<object[]>>(methodCall, allParameters);
        return lambda.Compile();
    }

    public static Func<object[], object> CreateLazyStaticMethodWithResult(MethodInfo method)
    {
        ParameterExpression allParameters;
        var methodCall = GenerateCallExpression(null, method, out allParameters);
        var lambda = Expression.Lambda<Func<object[], object>>(methodCall, allParameters);
        return lambda.Compile();
    }

    public static Action<object[]> CreateLazyStaticMethodWithNoResult(MethodInfo method)
    {
        ParameterExpression allParameters;
        var methodCall = GenerateCallExpression(null, method, out allParameters);
        var lambda = Expression.Lambda<Action<object[]>>(methodCall, allParameters);
        return lambda.Compile();
    }


    /// <summary>
    /// Generate expression call
    /// </summary>
    /// <param name="instance">If instance is NULL, then it method will be treated as static method</param>
    private static MethodCallExpression GenerateCallExpression(object instance, MethodBase method, out ParameterExpression allParameters)
    {
        var parameters = GenerateParameters(method, out allParameters);

        var methodInfo = method as MethodInfo;
        // it's non static method
        if (instance != null)
        {
            var instanceExpr = Expression.Convert(Expression.Constant(instance), instance.GetType());
            return Expression.Call(instanceExpr, methodInfo, parameters.ToArray());
        }

        // it's static method
        return Expression.Call(methodInfo, parameters.ToArray());
    }

    public static Func<object[], object> GenerateLazyConstructorCall(ConstructorInfo constructor)
    {
        ParameterExpression allParameters;
        var parameters = GenerateParameters(constructor, out allParameters);

        var newExpr = Expression.New(constructor, parameters.ToArray());
        var lambda = Expression.Lambda<Func<object[], object>>(newExpr, allParameters);

        return lambda.Compile();
    }

    private static List<Expression> GenerateParameters(MethodBase method, out ParameterExpression allParameters)
    {
        allParameters = Expression.Parameter(typeof(object[]), "params");
        ParameterInfo[] methodMarameters = method.GetParameters();
        List<Expression> parameters = new List<Expression>();
        for (int i = 0; i < methodMarameters.Length; i++)
        {
            var indexExpr = Expression.Constant(i);
            var item = Expression.ArrayIndex(allParameters, indexExpr);
            var converted = Expression.Convert(item, methodMarameters[i].ParameterType);
            parameters.Add(converted);
        }

        return parameters;
    }
}

Real-world illustration: https://dotnetfiddle.net/lHB2kE

UPDATE I added examples for calling methods and constructors to the code:

  1. Method for instances without a return object
  2. instance function that returns a specific object
  3. Method static that doesn't return an object
  4. Static function that returns a single item
  5. use of a sample constructor
4
10/29/2014 11:39:26 AM


Related Questions





Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow