Hi I'm trying to create a function that dynamically creates a delegate with the same return value and the same parameters as a MethodInfo it receives as parameter and also and this is very important the same parameter names!
What I did so far is create a function that returns a lambda that receives the same parameter types and has the same return value as the MethodInfo but it doesn't have the parameter names:
static void Example()
{
Person adam = new Person();
MethodInfo method = typeof(Person).GetMethod("Jump");
Delegate result = CreateDelegate(adam, method);
result.DynamicInvoke((uint)4, "Yeahaa");
}
private static Delegate CreateDelegate(object instance, MethodInfo method)
{
var parametersInfo = method.GetParameters();
Expression[] expArgs = new Expression[parametersInfo.Length];
List<ParameterExpression> lstParamExpressions = new List<ParameterExpression>();
for (int i = 0; i < expArgs.Length; i++)
{
expArgs[i] = Expression.Parameter(parametersInfo[i].ParameterType, parametersInfo[i].Name);
lstParamExpressions.Add((ParameterExpression)expArgs[i]);
}
MethodCallExpression callExpression = Expression.Call(Expression.Constant(instance), method, expArgs);
LambdaExpression lambdaExpression = Expression.Lambda(callExpression, lstParamExpressions);
return lambdaExpression.Compile();
}
private class Person
{
public void Jump(uint height, string cheer)
{
Console.WriteLine("Person jumped " + height + " "+ cheer);
}
}
Does anyone have any suggestions how I can do that?
To make it clear, the reason I care about the parameter names is so I would be able to activate the delegate with the parameter names, so I could call it like this (cheer="YAY!', height=3)
(My application is integrated with Python that's how I'll be able to do it without DynamicInvoke and this is also the reason why the parameter names are so important
and also why I wrote '=' and not ':')
To dynamically create a delegate, you can use Reflection.Emit. Since delegates are special types in .Net, the code to create it is not quite obvious. The following is based on reflected code of methods used by Expression.Lambda(). There, it's used to create custom delegate types in situations, where there is no Action or Func delegate available (more than 17 parameters, or parameters with ref or out).
class DelegateTypeFactory
{
private readonly ModuleBuilder m_module;
public DelegateTypeFactory()
{
var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName("DelegateTypeFactory"), AssemblyBuilderAccess.RunAndCollect);
m_module = assembly.DefineDynamicModule("DelegateTypeFactory");
}
public Type CreateDelegateType(MethodInfo method)
{
string nameBase = string.Format("{0}{1}", method.DeclaringType.Name, method.Name);
string name = GetUniqueName(nameBase);
var typeBuilder = m_module.DefineType(
name, TypeAttributes.Sealed | TypeAttributes.Public, typeof(MulticastDelegate));
var constructor = typeBuilder.DefineConstructor(
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig | MethodAttributes.Public,
CallingConventions.Standard, new[] { typeof(object), typeof(IntPtr) });
constructor.SetImplementationFlags(MethodImplAttributes.CodeTypeMask);
var parameters = method.GetParameters();
var invokeMethod = typeBuilder.DefineMethod(
"Invoke", MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public,
method.ReturnType, parameters.Select(p => p.ParameterType).ToArray());
invokeMethod.SetImplementationFlags(MethodImplAttributes.CodeTypeMask);
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
invokeMethod.DefineParameter(i + 1, ParameterAttributes.None, parameter.Name);
}
return typeBuilder.CreateType();
}
private string GetUniqueName(string nameBase)
{
int number = 2;
string name = nameBase;
while (m_module.GetType(name) != null)
name = nameBase + number++;
return name;
}
}
If you care about performance, you might want to create a cache of some sort, so that you don't create the same delegate type over and over.
The only modification in your code will be the line that creates lambdaExpression:
LambdaExpression lambdaExpression = Expression.Lambda(
s_delegateTypeFactory.CreateDelegateType(method),
callExpression, lstParamExpressions);
But you actually don't need to deal with Expressions at all. Delegate.CreateDelegate() is enough:
private static Delegate CreateDelegate(object instance, MethodInfo method)
{
return Delegate.CreateDelegate(
s_delegateTypeFactory.CreateDelegateType(method), instance, method);
}
I have just stumbled upon a nice way to solve this issue, it looks like this for delegates to a static method:
private static Delegate CreateDelegate(MethodInfo method) {
var paramTypes = method.GetParameters().Select(p => p.ParameterType);
Type delegateType = Expression.GetDelegateType(paramTypes.Append(method.ReturnType).ToArray());
return Delegate.CreateDelegate(delegateType, method, true);
}
It uses this extension method:
public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> collection, TSource element) {
if (collection == null) throw new ArgumentNullException("collection");
foreach (TSource element1 in collection) yield return element1;
yield return element;
}
The open source framework ImpromptuInterface (v5.6.7 via nuget) has a DLR currying/partial apply implementation that I think would work in this case as long as you don't need a literal delegate.
Here is the c# version of creating it and invoking it:
dynamic jump =Impromptu.Curry(adam).Jump();
jump(cheer:"yay", height:(uint)3);
So jump isn't a literal delegate, you cannot reflect it, but you can invoke it directly as if it were a delegate and it's a DLR object so my guess is that it would work just the same in python.
