为任何方法创建 Func 或 Action（在 c# 中使用反射）
Posted
技术标签:
【中文标题】为任何方法创建 Func 或 Action（在 c# 中使用反射）【英文标题】：Create Func or Action for any method (using reflection in c#) 【发布时间】：2012-10-14 01:09:05 【问题描述】：我的应用程序可以根据设置动态加载 dll 来自数据库（文件、类和方法名）。为了方便、加快和减少反射的使用，我想要一个缓存....
遵循使用的想法：
MethodInfo.Invoke
没有什么表演（Reflection Performance - Create Delegate (Properties C#)） 我想翻译任何对方法的调用。我想到了一些可以像这样工作的东西：
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");
一个要求是所有参数都可以是对象。
我正在尝试处理表达式，到目前为止我有这样的事情：
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;
有没有办法简化这段代码？ （我相信可以只使用泛型来创建方法。。）当你有 3、4、5 时，任何参数都和我一样？
我在想，如果有这样的事情怎么办：
https://codereview.stackexchange.com/questions/1070/generic-advanced-delegate-createdelegate-using-expression-trees
但我将有多个参数（在动作或函数中），这个参数（第一个参数）是一个要执行的对象。 这可能吗？
【问题讨论】：
我的答案没有 cmets... 你试过了吗？有帮助吗？你还需要帮助吗？ @MiguelAngelo 抱歉，您的代码实际上看起来是最好的选择！！！我相信这正是我正在寻找的，只希望有时间进行更多测试:) 【参考方案1】：我已经制作了一个满足您所有要求的示例程序（我想！）
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 类：
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);
工作原理
核心是BuildDelegate方法：
static T BuildDelegate<T>(MethodInfo method)
示例调用：var action = BuildDelegate<Action<object, int>>(mi);
参数规则：
如果传递的方法是实例方法，则生成的委托的第一个参数将接受包含方法本身的对象的实例。所有其他参数都将传递给该方法。
如果传递的方法是静态方法，那么生成的委托的所有参数都会传递给该方法。
缺少的参数将传递默认值。
额外的参数将被丢弃。【讨论】：
我检测到这个答案不支持返回值的转换......也就是说，你可以使用Func<object>，比如说int MyMethod()......如果你有需要的，尽管问，我会改的！ =)
这行的逻辑我没看懂：Expression.Constant(Activator.CreateInstance(callParamType.ParameterType));在我的测试中，它从来没有被调用过..它什么时候被调用？
如果未提供默认对象，则用于创建它...例如你想要一个Action<object, int> 用于像void Method(int param1, int param2) 这样的方法...请注意，param2 不包含在操作中，因此生成的代码必须创建一个默认值才能传递给该方法...它将调用Activator.CreateInstance(typeof(int))，即0（默认的 int 值）。
现在，看看它，如果可以在 BuildDelegate 方法上传递缺失参数的默认值会更好......而不是仅仅假设你想使用默认值价值。
更改了答案以允许BuildDelegate 方法接收缺失参数的默认值。我还在Program.Main 方法中提供了一个示例。【参考方案2】：
Delegate.CreateDelegate 比构建表达式树要简单得多。
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】：我遇到了一个非常相似的场景，我发现以下操作非常好。
首先，让我们设置我们的测试 Foo 类：
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;
接下来，我们创建一组方法来创建可重用的方法包装器：
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;
那么我们可以这样使用：
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");
产生输出：
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
【讨论】：
似乎足够好。进行一些调整只会使所有内容都集中在一种方法中。不确定，但使用 DynamicInvoke，性能会略有下降。无论如何，感谢您的贡献。 @J.Lennon 如果您正在寻找更好的性能，则需要将动态调用替换为表达式或发出 IL，这比预期的要容易得多。跨度> 【参考方案4】：如果您可以在项目中使用库，请尝试 Impromptu Interfaces（可在此处获得：http://code.google.com/p/impromptu-interface/）或在 nuget 上。
这有很多处理类型反射的功能，还实现了内部缓存。我一直在一个严重依赖反射的项目中使用它，性能非常好。
这个库本身有很多功能，但它也可以处理像你这样的场景。
【讨论】：
【参考方案5】：我有点不确定你真正想要做什么，但也许这有帮助？
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");
但你会失去强类型，因为所有参数都是object，我有点不确定你真正想要完成什么。
【讨论】：
您的代码运行良好，但不合适。但问题是使用调用 MethodInfo.Invoke 又重又慢。使用委托或 IL 或表达式树进行调用的性能要高得多。我会在我的问题中添加信息..【参考方案6】：我不确定，但你为什么不使用dynamic 类型？
例如：
dynamic foo = Activator.CreateInstance(customType);
foo.AnyMethod();
foo.AnySetValue("test string");
foo.OtherMethod("method", "with", "many", "parameters");
【讨论】：
这适用于大多数情况，但如果我需要更改方法名称（例如），我不知道如何动态调用此模式。以上是关于为任何方法创建 Func 或 Action（在 c# 中使用反射）的主要内容，如果未能解决你的问题，请参考以下文章
为什么我需要将方法强制转换为`Action`或`Func`以在值元组中使用它？