J. *_*non 13 c# reflection lambda expression-trees
我的应用程序可以根据数据库中的设置(文件,类和方法名称)动态加载dll.为了方便,加快和减少反射的使用,我想有一个缓存....
遵循使用的想法:
MethodInfo.Invoke
没有任何表演(反映性能 - 创建代表(属性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,任何参数像我一样？
我在想,如果有这样的事情怎么办:
但是我会有更多的参数(在动作或函数中),这个参数(第一个参数)是一个要执行的对象.这可能吗？
Mig*_*elo 15
我已经制作了一个满足您所有要求的示例程序(我想!)
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);
参数规则:
如果传递的方法是实例方法,则生成的委托的第一个参数将接受包含方法本身的对象的实例.所有其他参数将传递给该方法.
如果传递的方法是静态方法,则生成的委托的所有参数都将传递给方法.
缺少参数将传递默认值.
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);