我想在某些方面或者（或两者） Delegate或MethodInfo资格这个称号。 然而，无论是提供我正在寻找的语法正派。 因此，简而言之，有没有一些办法，我可以写：
FunctionPointer foo = // whatever, create the function pointer using mechanisms
foo();
我不能用了坚实的委托（即使用delegate关键字来声明委托类型），因为没有办法知道，直到运行时的确切参数列表的方式。 作为参考，这是我一直在玩弄LINQPad目前，在B会（大部分）用户生成的代码，所以将Main ，因此对于精密到我的用户，我想删除.Call ：
void Main()
{
A foo = new B();
foo["SomeFuntion"].Call();
}
// Define other methods and classes here
interface IFunction {
void Call();
void Call(params object[] parameters);
}
class A {
private class Function : IFunction {
private MethodInfo _mi;
private A _this;
public Function(A @this, MethodInfo mi) {
_mi = mi;
_this = @this;
}
public void Call() { Call(null); }
public void Call(params object[] parameters) {
_mi.Invoke(_this, parameters);
}
}
Dictionary<string, MethodInfo> functions = new Dictionary<string, MethodInfo>();
public A() {
List<MethodInfo> ml = new List<MethodInfo>(this.GetType().GetMethods());
foreach (MethodInfo mi in typeof(Object).GetMethods())
{
for (int i = 0; i < ml.Count; i++)
{
if (ml[i].Name == mi.Name)
ml.RemoveAt(i);
}
}
foreach (MethodInfo mi in ml)
{
functions[mi.Name] = mi;
}
}
public IFunction this[string function] {
get {
if (!functions.ContainsKey(function))
throw new ArgumentException();
return new Function(this, functions[function]);
}
}
}
sealed class B : A {
public void SomeFuntion() {
Console.WriteLine("SomeFunction called.");
}
}
你说你想保留的数量和参数类型开放，但你可以做到这一点与delgate：
public delegate object DynamicFunc(params object[] parameters);
这正是您目前有同样的事情。 试试这个：
class Program
{
static void Main(string[] args)
{
DynamicFunc f = par =>
{
foreach (var p in par)
Console.WriteLine(p);
return null;
};
f(1, 4, "Hi");
}
}
你可以把一个实例方法的委托作为非常相似，你的Function类：对象的一个MethodInfo 。 因此，有没有必要重写。
也能起到C和C ++指针没有任何接近你所需要的：他们不能被绑定到一个对象实例和功能，此外，他们都是静态类型，而不是动态类型。
如果你想在一个DynamicFunc授人以“包装”任何其他方法，试试这个：
public static DynamicFunc MakeDynamicFunc(object target, MethodInfo method)
{
return par => method.Invoke(target, par);
}
public static void Foo(string s, int n)
{
Console.WriteLine(s);
Console.WriteLine(n);
}
然后：
DynamicFunc f2 = MakeDynamicFunc(null, typeof(Program).GetMethod("Foo"));
f2("test", 100);
请注意，我使用的是静态方法Foo所以我通过null的实例，但如果它是一个实例方法，我会通过绑定到的对象。 Program恰好是我的静态方法中定义的类。
当然，如果你传递错误的参数类型，那么你在运行时出现错误。 我可能会寻找一种方式让尽可能多的类型信息在编译时尽可能地捕捉到设计程序。
这里的代码，你可以使用另一个位; 反思是相当缓慢的，所以如果你希望你的动态函数调用被频繁调用，你不想委托内部method.Invoke：
public delegate void DynamicAction(params object[] parameters);
static class DynamicActionBuilder
{
public static void PerformAction0(Action a, object[] pars) { a(); }
public static void PerformAction1<T1>(Action<T1> a, object[] p) {
a((T1)p[0]);
}
public static void PerformAction2<T1, T2>(Action<T1, T2> a, object[] p) {
a((T1)p[0], (T2)p[1]);
}
//etc...
public static DynamicAction MakeAction(object target, MethodInfo mi) {
Type[] typeArgs =
mi.GetParameters().Select(pi => pi.ParameterType).ToArray();
string perfActName = "PerformAction" + typeArgs.Length;
MethodInfo performAction =
typeof(DynamicActionBuilder).GetMethod(perfActName);
if (typeArgs.Length != 0)
performAction = performAction.MakeGenericMethod(typeArgs);
Type actionType = performAction.GetParameters()[0].ParameterType;
Delegate action = Delegate.CreateDelegate(actionType, target, mi);
return (DynamicAction)Delegate.CreateDelegate(
typeof(DynamicAction), action, performAction);
}
}
你可以使用这样的：
static class TestDab
{
public static void PrintTwo(int a, int b) {
Console.WriteLine("{0} {1}", a, b);
Trace.WriteLine(string.Format("{0} {1}", a, b));//for immediate window.
}
public static void PrintHelloWorld() {
Console.WriteLine("Hello World!");
Trace.WriteLine("Hello World!");//for immediate window.
}
public static void TestIt() {
var dynFunc = DynamicActionBuilder.MakeAction(null,
typeof(TestDab).GetMethod("PrintTwo"));
dynFunc(3, 4);
var dynFunc2 = DynamicActionBuilder.MakeAction(null,
typeof(TestDab).GetMethod("PrintHelloWorld"));
dynFunc2("extraneous","params","allowed"); //you may want to check this.
}
}
这将是快了不少; 每个动态呼叫将涉及每PARAM 1种类型检测，2次代表呼叫，以及一个阵列结构由于PARAMS式传递。
