问题
My application works with loading dll's dynamically, based on settings from the database (file, class and method names). To facilitate, expedite and reduce the use of reflection I would like to have a cache....
Following the idea that using:
MethodInfo.Invoke
Is nothing performative ( Reflection Performance - Create Delegate (Properties C#)) I would like to translate any call to methods. I thought of something that would work like this:
public static T Create<T>(Type type, string methodName) // or
public static T Create<T>(MethodInfo info) // to use like this:
var action = Create<Action<object>>(typeof(Foo), "AnySetValue");
One requirement is that all the parameters, can be object.
I'm trying to deal with expressions, and so far I have something like this:
private void Sample()
{
var assembly = Assembly.GetAssembly(typeof(Foo));
Type customType = assembly.GetType("Foo");
var actionMethodInfo = customType.GetMethod("AnyMethod");
var funcMethodInfo = customType.GetMethod("AnyGetString");
var otherActionMethod = customType.GetMethod("AnySetValue");
var otherFuncMethodInfo = customType.GetMethod("OtherGetString");
var foo = Activator.CreateInstance(customType);
var actionAccessor = (Action<object>)BuildSimpleAction(actionMethodInfo);
actionAccessor(foo);
var otherAction = (Action<object, object>)BuildOtherAction(otherActionMethod);
otherAction(foo, string.Empty);
var otherFuncAccessor = (Func<object, object>)BuildFuncAccessor(funcMethodInfo);
otherFuncAccessor(foo);
var funcAccessor = (Func<object,object,object>)BuildOtherFuncAccessor(otherFuncMethodInfo);
funcAccessor(foo, string.Empty);
}
static Action<object> BuildSimpleAction(MethodInfo method)
{
var obj = Expression.Parameter(typeof(object), "o");
Expression<Action<object>> expr =
Expression.Lambda<Action<object>>(
Expression.Call(
Expression.Convert(obj, method.DeclaringType),
method), obj);
return expr.Compile();
}
static Func<object, object> BuildFuncAccessor(MethodInfo method)
{
var obj = Expression.Parameter(typeof(object), "o");
Expression<Func<object, object>> expr =
Expression.Lambda<Func<object, object>>(
Expression.Convert(
Expression.Call(
Expression.Convert(obj, method.DeclaringType),
method),
typeof(object)),
obj);
return expr.Compile();
}
static Func<object, object, object> BuildOtherFuncAccessor(MethodInfo method)
{
var obj = Expression.Parameter(typeof(object), "o");
var value = Expression.Parameter(typeof(object));
Expression<Func<object, object, object>> expr =
Expression.Lambda<Func<object, object, object>>(
Expression.Call(
Expression.Convert(obj, method.DeclaringType),
method,
Expression.Convert(value, method.GetParameters()[0].ParameterType)),
obj, value);
return expr.Compile();
}
static Action<object, object> BuildOtherAction(MethodInfo method)
{
var obj = Expression.Parameter(typeof(object), "o");
var value = Expression.Parameter(typeof(object));
Expression<Action<object, object>> expr =
Expression.Lambda<Action<object, object>>(
Expression.Call(
Expression.Convert(obj, method.DeclaringType),
method,
Expression.Convert(value, method.GetParameters()[0].ParameterType)),
obj,
value);
return expr.Compile();
}
public class Foo
{
public void AnyMethod() {}
public void AnySetValue(string value) {}
public string AnyGetString()
{ return string.Empty; }
public string OtherGetString(string value)
{ return string.Empty; }
}
Is there any way to simplify this code? (I believe it is possible to create a method only using generic..) And when you have 3, 4, 5, any parameters as I do?
I was thinking, what if there was something like this:
https://codereview.stackexchange.com/questions/1070/generic-advanced-delegate-createdelegate-using-expression-trees
but I'll have more one parameter (in action or function), this parameter (first parameter) an object to perform. Is this possible?
回答1:
I have made a sample program that fulfills all your requirements (I think!)
class Program
{
class MyType
{
public MyType(int i) { this.Value = i; }
public void SetValue(int i) { this.Value = i; }
public void SetSumValue(int a, int b) { this.Value = a + b; }
public int Value { get; set; }
}
public static void Main()
{
Type type = typeof(MyType);
var mi = type.GetMethod("SetValue");
var obj1 = new MyType(1);
var obj2 = new MyType(2);
var action = DelegateBuilder.BuildDelegate<Action<object, int>>(mi);
action(obj1, 3);
action(obj2, 4);
Console.WriteLine(obj1.Value);
Console.WriteLine(obj2.Value);
// Sample passing a default value for the 2nd param of SetSumValue.
var mi2 = type.GetMethod("SetSumValue");
var action2 = DelegateBuilder.BuildDelegate<Action<object, int>>(mi2, 10);
action2(obj1, 3);
action2(obj2, 4);
Console.WriteLine(obj1.Value);
Console.WriteLine(obj2.Value);
// Sample without passing a default value for the 2nd param of SetSumValue.
// It will just use the default int value that is 0.
var action3 = DelegateBuilder.BuildDelegate<Action<object, int>>(mi2);
action3(obj1, 3);
action3(obj2, 4);
Console.WriteLine(obj1.Value);
Console.WriteLine(obj2.Value);
}
}
DelegateBuilder class:
public class DelegateBuilder
{
public static T BuildDelegate<T>(MethodInfo method, params object[] missingParamValues)
{
var queueMissingParams = new Queue<object>(missingParamValues);
var dgtMi = typeof(T).GetMethod("Invoke");
var dgtRet = dgtMi.ReturnType;
var dgtParams = dgtMi.GetParameters();
var paramsOfDelegate = dgtParams
.Select(tp => Expression.Parameter(tp.ParameterType, tp.Name))
.ToArray();
var methodParams = method.GetParameters();
if (method.IsStatic)
{
var paramsToPass = methodParams
.Select((p, i) => CreateParam(paramsOfDelegate, i, p, queueMissingParams))
.ToArray();
var expr = Expression.Lambda<T>(
Expression.Call(method, paramsToPass),
paramsOfDelegate);
return expr.Compile();
}
else
{
var paramThis = Expression.Convert(paramsOfDelegate[0], method.DeclaringType);
var paramsToPass = methodParams
.Select((p, i) => CreateParam(paramsOfDelegate, i + 1, p, queueMissingParams))
.ToArray();
var expr = Expression.Lambda<T>(
Expression.Call(paramThis, method, paramsToPass),
paramsOfDelegate);
return expr.Compile();
}
}
private static Expression CreateParam(ParameterExpression[] paramsOfDelegate, int i, ParameterInfo callParamType, Queue<object> queueMissingParams)
{
if (i < paramsOfDelegate.Length)
return Expression.Convert(paramsOfDelegate[i], callParamType.ParameterType);
if (queueMissingParams.Count > 0)
return Expression.Constant(queueMissingParams.Dequeue());
if (callParamType.ParameterType.IsValueType)
return Expression.Constant(Activator.CreateInstance(callParamType.ParameterType));
return Expression.Constant(null);
}
}
How it works
The core is the BuildDelegate method:
static T BuildDelegate<T>(MethodInfo method)
- T is the delegate type you want to create.
- method is the MethodInfo of the method you want to be called by the generated delegate.
Example call: var action = BuildDelegate<Action<object, int>>(mi);
Rules for parameters:
If the method passed is an instance method, first parameter of the generated delegate will accept the instance of the object, that contains the method itself. All other parameter will be passed to the method.
If the method passed is a static method, then all parameters of the generated delegate will be passed to the method.
Missing parameters will have default values passed.
- Extra parameters will be discarded.
回答2:
Delegate.CreateDelegate is much simpler than building expression trees.
var assembly = Assembly.GetAssembly(typeof(Foo));
Type customType = assembly.GetType("Foo");
var actionMethodInfo = customType.GetMethod("AnyMethod");
var foo = Activator.CreateInstance(customType);
Action action = (Action)Delegate.CreateDelegate(typeof(Action), foo, actionMethodInfo);
回答3:
I've ran into a very similar scenario and I've found the following to work very well.
First, let's set up our test Foo class:
public class Foo
{
private string _name;
public Foo(string name)
{
_name = name;
}
public void AnyMethod()
{
Console.WriteLine("{0} Called: AnyMethod()", _name);
}
public void AnySetValue(string value)
{
Console.WriteLine("{0} Called: AnySetValue(string) with {1}", _name, value);
}
public string AnySetString(string value)
{
Console.WriteLine("{0} Called: AnySetString(string) with {1}", _name, value);
return value;
}
}
Next, we create a set of methods to create our reusable method wrappers:
public static Action<object> CreateReusableAction<TClass>(string methodName)
{
var method = typeof(TClass).GetMethod(methodName);
var del = Delegate.CreateDelegate(typeof(Action<TClass>), method);
Action<object> caller = (instance) => del.DynamicInvoke(instance);
return caller;
}
public static Action<object, object> CreateReusableAction<TClass, TParam1>(string methodName)
{
var method = typeof(TClass).GetMethod(methodName, new Type[] { typeof(TParam1) });
var del = Delegate.CreateDelegate(typeof(Action<TClass, TParam1>), method);
Action<object, object> caller = (instance, param) => del.DynamicInvoke(instance, param);
return caller;
}
public static Func<object, object, object> CreateReusableFunction<TClass, TParam1, TReturn>(string methodName)
{
var method = typeof(TClass).GetMethod(methodName, new Type[] { typeof(TParam1) });
var del = Delegate.CreateDelegate(typeof(Func<TClass, TParam1, TReturn>), method);
Func<object, object, object> caller = (instance, param) => (TReturn)del.DynamicInvoke(instance, param);
return caller;
}
Then we can use it as follows:
var myFoo = new Foo("myFoo");
var otherFoo = new Foo("otherFoo");
var anyMethod = CreateReusableAction<Foo>("AnyMethod");
anyMethod(myFoo);
anyMethod(otherFoo);
var anySetValue = CreateReusableAction<Foo, string>("AnySetValue");
anySetValue(myFoo, "Value 1");
anySetValue(otherFoo, "Value 2");
var anySetString = CreateReusableFunction<Foo, string, string>("AnySetString");
var firstResult = anySetString(myFoo, "MyFooValue1");
var secondResult = anySetString(otherFoo, "OtherFooValue1");
Which produces the output:
myFoo Called: AnyMethod()
otherFoo Called: AnyMethod()
myFoo Called: AnySetValue(string) with Value 1
otherFoo Called: AnySetValue(string) with Value 2
myFoo Called: AnySetString(string) with MyFooValue1
otherFoo Called: AnySetString(string) with OtherFooValue1
回答4:
If you can use libraries in your project, try the Impromptu Interfaces (available here: http://code.google.com/p/impromptu-interface/) or on nuget.
This has a lot of functionality for handling reflection on types and also implements internal caching. I've been using it in a project that relies heavily on reflection and the performance is really good.
The library itself has a lot of functionality but it also handles scenarios like yours.
回答5:
I'm not sure, but why you don't use the dynamic type?
For example:
dynamic foo = Activator.CreateInstance(customType);
foo.AnyMethod();
foo.AnySetValue("test string");
foo.OtherMethod("method", "with", "many", "parameters");
回答6:
I'm a bit unsure what you are really trying to do, but maybe this helps?
public static Func<object, object[], object> CreateDelegate(MethodInfo method)
{
return new Func<object, object[], object>((object instance, object[] args) => method.Invoke(instance, args));
}
// Merely providing syntactic suger, ie able to write
// method.MyInvoke(instance, arg1, arg2, arg3, arg4)
// instead of having to put the args in an array, ie Invoke(instance, new object[]{arg1, arg2}) etc
public static object MyInvoke(this Func<object, object[], object> func, object instance, params object[] args)
{
return func(instance, args);
}
public static void TestCode()
{
var method = typeof(string).GetMethod("get_Length");
var wrappfunc = CreateDelegate(method);
// Calling get_Length (ie Length property) on the string "klasjf"
wrappfunc.MyInvoke("klasjf");
}
You will lose the strong typing though, since all the arguments are object, and I am a bit unsure what you really are trying to accomplish.
来源：https://stackoverflow.com/questions/13041674/create-func-or-action-for-any-method-using-reflection-in-c