Test the generic class:
public class GenericTest<T, W, X>
{
public void Show(T t, W w, X x)
{
Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
}
}
//泛型方法
public class GenericMethod
{
public void Show<T, W, X>(T t, W w, X x)
{
Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
}
}
public class GenericDouble<T>
{
public void Show<W, X>(T t, W w, X x)
{
Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
}
}
Test common methods of common classes:
public class ReflectionTest
{
#region Identity
/// <summary>
/// 无参构造函数
/// </summary>
public ReflectionTest()
{
Console.WriteLine("这里是{0}无参数构造函数", this.GetType());
}
/// <summary>
/// 带参数构造函数
/// </summary>
/// <param name="name"></param>
public ReflectionTest(string name)
{
Console.WriteLine("这里是{0} 有参数构造函数", this.GetType());
}
public ReflectionTest(int id)
{
Console.WriteLine("这里是{0} 有参数构造函数", this.GetType());
}
public ReflectionTest(int id, string name)
{
//typeof(int);
//Type //id.GetType();
Console.WriteLine("这里是{0} 有参数构造函数", this.GetType());
}
#endregion
#region Method
/// <summary>
/// 无参方法
/// </summary>
public void Show1()
{
Console.WriteLine("这里是{0}的Show1", this.GetType());
}
/// <summary>
/// 有参数方法
/// </summary>
/// <param name="id"></param>
public void Show2(int id)
{
Console.WriteLine("这里是{0}的Show2", this.GetType());
}
/// <summary>
/// 重载方法之一
/// </summary>
/// <param name="id"></param>
/// <param name="name"></param>
public void Show3(int id, string name)
{
Console.WriteLine("这里是{0}的Show3", this.GetType());
}
/// <summary>
/// 重载方法之二
/// </summary>
/// <param name="name"></param>
/// <param name="id"></param>
public void Show3(string name, int id)
{
Console.WriteLine("这里是{0}的Show3_2", this.GetType());
}
/// <summary>
/// 重载方法之三
/// </summary>
/// <param name="id"></param>
public void Show3(int id)
{
Console.WriteLine("这里是{0}的Show3_3", this.GetType());
}
/// <summary>
/// 重载方法之四
/// </summary>
/// <param name="name"></param>
public void Show3(string name)
{
Console.WriteLine("这里是{0}的Show3_4", this.GetType());
}
/// <summary>
/// 重载方法之五
/// </summary>
public void Show3()
{
Console.WriteLine("这里是{0}的Show3_1", this.GetType());
}
/// <summary>
/// 私有方法
/// </summary>
/// <param name="name"></param>
private void Show4(string name) //肯定是可以的
{
Console.WriteLine("这里是{0}的Show4", this.GetType());
}
/// <summary>
/// 静态方法
/// </summary>
/// <param name="name"></param>
public static void Show5(string name)
{
Console.WriteLine("这里是{0}的Show5", typeof(ReflectionTest));
}
#endregion
}
try
{
#region 反射调用无参无返回值方法
//动态加载DLL
Assembly assembly = Assembly.LoadFrom("TestCommon.dll");
//获取指定类型
Type type = assembly.GetType("TestCommon.ReflectionTest");
//获取指定方法
MethodInfo method = type.GetMethod("Show1");
//获取有参构造函数
ConstructorInfo info = type.GetConstructor(new Type[] {
typeof(int) });
//创建对象
object oTest = info.Invoke(new object[] {
123 });
//调用方法
method.Invoke(oTest, null);
#endregion
#region 反射调用有参方法
Assembly assembly = Assembly.LoadFrom("TestCommon.dll");
Type type = assembly.GetType("TestCommon.ReflectionTest");
//使用默认构造函数
object oTest = Activator.CreateInstance(type);
//获取有参方法
MethodInfo method = type.GetMethod("Show2");
method.Invoke(oTest, new object[] {
2 });
#endregion
#region 反射调用重载方法普通方法
Assembly assembly = Assembly.LoadFrom("TestCommon.dll");
Type type = assembly.GetType("TestCommon.ReflectionTest");
//调用有参构造函数
object oTest = Activator.CreateInstance(type, new object[] {
888, "zs" });//直接赋值参数，自动去找有对应参数的构造函数去
//MethodInfo method=type.GetMethod("Show3");//重载方法需指明调用目标
MethodInfo method = type.GetMethod("Show3", new Type[] {
typeof(int), typeof(string) });
MethodInfo method1 = type.GetMethod("Show3", new Type[] {
typeof(int) });
MethodInfo method2 = type.GetMethod("Show3", new Type[] {
typeof(string) });
//调用
method.Invoke(oTest, new object[] {
14, "zs" });
#endregion
#region 反射调用私有方法
Assembly assembly = Assembly.LoadFrom("TestCommon.dll");
Type type = assembly.GetType("TestCommon.ReflectionTest");
object oTest = Activator.CreateInstance(type);
//获取私有方法
//MethodInfo method=type.GetMethod("Show4");//对于私有方法直接获取是不行的
//BindingFlags.Public|BindingFlags.Instance 默认查找public、instance内容
//如果要查找私有成员 需要指定BindingFlags查找非公共的实例成员BindingFlags.NonPublic|BindingFlags.Instance
//如果只设置 BindingFlags.NonPublic，覆盖默认设置 就不会查找实例成员了 也不会成功查到
MethodInfo method = type.GetMethod("Show4", BindingFlags.NonPublic | BindingFlags.Instance);
method.Invoke(oTest, new object[] {
"Peter" });
#endregion
#region 反射调用静态成员
Assembly assembly = Assembly.LoadFrom("TestCommon.dll");
Type type = assembly.GetType("TestCommon.ReflectionTest");
//搜索静态成员和公共成员
//MethodInfo method=type.GetMethod("Show5", BindingFlags.Static | BindingFlags.Public);//OK
MethodInfo method = type.GetMethod("Show5");
object oTest = Activator.CreateInstance(type);
//method.Invoke(oTest, new object[]{ "zs" }); ok
//因为是静态成员，所以调用的时候可以不需要对象
method.Invoke(null, new object[] {
"zss" });
#endregion
#region 反射调用泛型方法
Assembly assembly = Assembly.LoadFrom("TestCommon.dll");
Type type = assembly.GetType("TestCommon.GenericMethod");
//获取泛型方法
MethodInfo method = type.GetMethod("Show");
//为泛型方法指定数据类型，替换T，W，S
MethodInfo GenericMethod = method.MakeGenericMethod(new Type[] {
typeof(int), typeof(string), typeof(DateTime) });
object oTest = Activator.CreateInstance(type);
//method.Invoke(oTest, new object[] { 12,"zs",DateTime.Now });//因为不确定参数类型(或未指定)，调用出错
//调用泛型方法
GenericMethod.Invoke(oTest, new object[] {
12, "121212", DateTime.Now });
#endregion
#region 反射调用泛型类中的普通方法
//看一下泛型类的全名称
Console.WriteLine(typeof(GenericTest<string, string, int>));
//TestCommon.GenericTest`3[System.String,System.String,System.Int32]
Assembly assembly = Assembly.LoadFrom("TestCommon.dll");
//Type type=assembly.GetType("GenericTest.GenericTest");//获取不了
Type type = assembly.GetType("TestCommon.GenericTest`3");
//Console.WriteLine(type);//TestCommon.GenericTest`3[T,W,X]
//为泛型类型参数赋值得到泛型类型
Type GenericType = type.MakeGenericType(new Type[] {
typeof(string), typeof(string), typeof(int) });
MethodInfo method = GenericType.GetMethod("Show");
object oTest = Activator.CreateInstance(GenericType);
//调用-->参数引用类的泛型类型，所以对应上就行 public void Show(T t, W w, X x) { }
method.Invoke(oTest, new object[] {
"peter", "jakey", 12 });
#endregion
#region 调用泛型类中的泛型方法
//public class GenericDouble<T>
//{
// public void Show<W, X>(T t, W w, X x)
// {
// Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
// }
//}
//看一下该泛型类型的TYPE全名称
//TestCommon.GenericDouble`1[System.String]
//---------------------------------------------------`标识泛型(类)，1-->泛型类的参数个数-----。
Console.WriteLine(typeof(GenericDouble<string>));
Assembly assembly = Assembly.LoadFrom("TestCommon.dll");
//获取类型
Type type = assembly.GetType("TestCommon.GenericDouble`1");
//指定泛型类型
Type GenericType = type.MakeGenericType(new Type[] {
typeof(string) });
object oTest = Activator.CreateInstance(GenericType);
//获取泛型方法
MethodInfo method = GenericType.GetMethod("Show");
//为泛型方法指定泛型参数类型并获得该泛型方法
MethodInfo GenericMethod = method.MakeGenericMethod(new Type[] {
typeof(string), typeof(string) });
//调用泛型方法
GenericMethod.Invoke(oTest, new object[] {
"peter","jakey","sunday"});
#endregion
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
Console.ReadKey();
}