将MethodInfo转化为Delegate的方式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
namespace MethodInfoInvokeDemo
{
public class ReflectTest
{
public void MethodWithNoParaNoReturn()
{
Console.WriteLine("不带参数且不返回值的方法");
}
public string MethodWithNoPara()
{
Console.WriteLine("不带参数且有返回值的方法");
return "MethodWithNoPara";
}
public string Method1(string str)
{
Console.WriteLine("带参数且有返回值的方法");
return str;
}
public string Method2(string str, int index)
{
Console.WriteLine("带参数且有返回值的方法");
return str + index.ToString();
}
public string Method3(string str, out string outStr)
{
outStr = "bbbb";
Console.WriteLine("带参数且有返回值的方法");
return str;
}
public static string StaticMethod()
{
Console.WriteLine("静态方法");
return "cccc";
}
}
class Program
{
static void Main(string[] args)
{
Type type = typeof(ReflectTest);
object reflectTest = Activator.CreateInstance(type);
//不带参数且不返回值的方法的调用
MethodInfo methodInfo = type.GetMethod("MethodWithNoParaNoReturn");
methodInfo.Invoke(reflectTest, null);
Console.WriteLine();
//不带参数且有返回值的方法的调用
methodInfo = type.GetMethod("MethodWithNoPara");
Console.WriteLine(methodInfo.Invoke(reflectTest, null).ToString());
Console.WriteLine();
//带参数且有返回值的方法的调用
methodInfo = type.GetMethod("Method1", new Type[]{typeof(string)});
Console.WriteLine(methodInfo.Invoke(reflectTest, new object[]{"测试"}).ToString());
Console.WriteLine();
//带多个参数且有返回值的方法的调用
methodInfo = type.GetMethod("Method2", new Type[] { typeof(string), typeof(int) });
Console.WriteLine(methodInfo.Invoke(reflectTest, new object[] { "测试", 100 }).ToString());
//Console.WriteLine();
//methodInfo = type.GetMethod("Method3", new Type[] { typeof(string), typeof(string) });
//string outStr = "";
//Console.WriteLine(methodInfo.Invoke(reflectTest, new object[] { "测试", outStr }).ToString());
Console.WriteLine();
//静态方法的调用
methodInfo = type.GetMethod("StaticMethod"); 
Console.WriteLine(methodInfo.Invoke(null, null).ToString());
Console.ReadKey();
}
}
}

有时再用反射的时候，需要将反射出的方法注册给某个事件，这是就需要将改方法转化为delegate后才能绑定到对应的事件上

可以通过Delegate.CreateDelegate的方法来实现，如下：

/// <summary>    
        /// 生成反射过来的MethodInfo到指定类型的委托    
        /// </summary>    
        /// <typeparam name="T">EventArgs泛型类型</typeparam>    
        /// <param name="instance">当前对象</param>    
        /// <param name="method">需要转化为delegate的方法</param>    
        /// <returns></returns>    
        public static Delegate CreateDelegateFromMethodInfo<T>(Object instance,MethodInfo method) where T:EventArgs//约束泛型T只能是来自EventArgs类型的    
        {    
    
            Delegate del = Delegate.CreateDelegate(typeof(EventHandler<T>), instance, method);    
            EventHandler<T> mymethod = del as EventHandler<T>;    
            return mymethod;    
        }    
    
        /// <summary>    
        /// 生成反射过来的MethodInfo到指定类型的委托    
        /// </summary>    
        /// <typeparam name="T">EventHandle泛型类型</typeparam>    
        /// <param name="instance">当前对象</param>    
        /// <param name="method">需要转化为delegate的方法</param>    
        /// <returns></returns>    
        public static Delegate CreateDelegateFromMethodInfoByDelegate<T>(Object instance, MethodInfo method)    
        {    
    
            Delegate del = Delegate.CreateDelegate(typeof(T), instance, method);    
            EventHandler mymethod = del as EventHandler;    
            return mymethod;    
        }

private void button3_Click(object sender, EventArgs e)  
        {  
            var Instance = Activator.CreateInstance(typeof(Form1)) as Form1;  
            MethodInfo methodInfo = typeof(Form1).GetMethod("Method1");   
  
             EventHandler dd = Delegate.CreateDelegate(typeof(EventHandler), Instance,methodInfo) as EventHandler;  
            dd(null, null);  
        }  
public void Method1(object sender, EventArgs e)  
        {  
            MessageBox.Show("ee");  
        }

• C#
• MethodInfo