IT评测·应用市场-qidao123.com

标题: 使用C#反射中的MAKEGENERICTYPE函数，来为泛型方法和泛型类指定（泛型的） [打印本页]
作者: 南飓风    时间: 2024-6-21 13:22
标题: 使用C#反射中的MAKEGENERICTYPE函数，来为泛型方法和泛型类指定（泛型的）
MakeGenericType 是一个在 C# 中用于创建开放范例的实例的方法。开放范例是一种未绑定范例参数的泛型范例。当你有一个泛型范例定义，并且想要用特定的范例实例化它时，你可以使用 MakeGenericType 方法。
  1. public Type MakeGenericType (params Type[] typeArguments);
复制代码
这个方法担当一个 Type[] 作为参数，此中包罗了用来更换泛型范例定义中的范例参数的范例。
比方，假设你有一个泛型类 Pair<T, U>，你想要创建一个 Pair<int, string> 的实例。你可以这样做：
  1. // 泛型类型定义
  2. public class Pair<T, U> {
  3.     public T First { get; set; }
  4.     public U Second { get; set; }
  5. }
  7. // 创建泛型类型的实例
  8. Type pairType = typeof(Pair<,>); // 获取开放类型
  9. Type[] typeArguments = { typeof(int), typeof(string) }; // 实例化类型参数
  10. Type pairInstanceType = pairType.MakeGenericType(typeArguments); // 创建实例类型
  12. // 创建实例
  13. object pairInstance = Activator.CreateInstance(pairInstanceType);
复制代码
在这个例子中，pairType 是一个开放范例，typeArguments 是用来更换 T 和 U 的详细范例。pairInstanceType 是一个已经绑定了详细范例参数的 Pair<int, string> 范例。最后，我们使用 Activator.CreateInstance 来创建这个范例的实例。

C#反射中的MakeGenericType函数可以用来指定泛型方法和泛型类的详细范例，方法如下面代码所示这里就不多讲了，详情看下面代码一切就清楚了：
  1. using System;
  2. using System.Reflection;
  4. namespace RFTest
  5. {
  6.     //类ReflectionTest中定义了一个泛型函数DisplayType和泛型类MyGenericClass
  7.     class ReflectionTest
  8.     {
  9.         //泛型类MyGenericClass有个静态函数DisplayNestedType
  10.         public class MyGenericClass<T>
  11.         {
  12.             public static void DisplayNestedType()
  13.             {
  14.                 Console.WriteLine(typeof(T).ToString());
  15.             }
  16.         }
  18.         public void DisplayType<T>()
  19.         {
  20.             Console.WriteLine(typeof(T).ToString());
  21.         }
  22.     }
  24.     class Program
  25.     {
  26.         static void Main(string[] args)
  27.         {
  28.             ReflectionTest rt = new ReflectionTest();
  30.             MethodInfo mi = rt.GetType().GetMethod("DisplayType");//先获取到DisplayType<T>的MethodInfo反射对象
  31.             mi.MakeGenericMethod(new Type[] { typeof(string) }).Invoke(rt, null);//然后使用MethodInfo反射对象调用ReflectionTest类的DisplayType<T>方法，这时要使用MethodInfo的MakeGenericMethod函数指定函数DisplayType<T>的泛型类型T
  33.             Type myGenericClassType = rt.GetType().GetNestedType("MyGenericClass`1");//这里获取MyGenericClass<T>的Type对象，注意GetNestedType方法的参数要用MyGenericClass`1这种格式才能获得MyGenericClass<T>的Type对象
  34.             myGenericClassType.MakeGenericType(new Type[] { typeof(float) }).GetMethod("DisplayNestedType", BindingFlags.Static | BindingFlags.Public).Invoke(null, null);
  35.             //然后用Type对象的MakeGenericType函数为泛型类MyGenericClass<T>指定泛型T的类型，比如上面我们就用MakeGenericType函数将MyGenericClass<T>指定为了MyGenericClass<float>，然后继续用反射调用MyGenericClass<T>的DisplayNestedType静态方法
  37.             Console.ReadLine();
  38.         }
  39.     }
  40. }
复制代码


C# 反射



反射是一种在运行时动态获取程序范例信息的技术，它可以用来查找和操纵程序中的范例、成员、属性和方法等。
(1)获取Type范例的几种方法：
(a)  实例调用GetType
(b)  typeof(范例)
(c)  Assembly.GetType(范例名称)
(d)  Type.GetType(范例全称)
(2)获取数组范例
typeof(范例).MakeArrayType()
如typeof(int).MakeArrayType()==typeof(int[]) //为true
(3)根据数组范例返回元素范例
typeof(int[]).GetElementType()==typeof(int)//为true
（4）范例具有Namespace,Name,FullName属性，FullName基本即是前两者组合在一起。
（5）数组，指针，ref,out 参数范例名称



MakeGenericType的使用:
MakeGenericType 方法用于创建一个泛型范例的实例，此中可以通过传递范例参数来指定详细的泛型参数范例。这在需要在运行时动态创建泛型范例的情况下非常有用。下面是一个示例代码演示怎样使用 MakeGenericType 方法：
假设有一个泛型类 MyGenericClass，你想要在运行时为其指定详细的范例参数并创建实例。首先，定义泛型类如下：

  1. using System;
  3. public class MyGenericClass<T>
  4. {
  5.     public void PrintType()
  6.     {
  7.         Console.WriteLine(typeof(T).Name);
  8.     }
  9. }
复制代码
接下来，可以使用 MakeGenericType 方法来动态创建泛型范例的实例：

  1. using System;
  3. class Program
  4. {
  5.     static void Main(string[] args)
  6.     {
  7.         // 获取泛型类型的定义
  8.         Type genericTypeDefinition = typeof(MyGenericClass<>);
  10.         // 指定泛型类型参数
  11.         Type[] typeArguments = { typeof(int) };
  13.         // 使用MakeGenericType创建泛型类型实例
  14.         Type specificType = genericTypeDefinition.MakeGenericType(typeArguments);
  15.         object instance = Activator.CreateInstance(specificType);
  17.         // 调用泛型类型的方法
  18.         var printMethod = specificType.GetMethod("PrintType");
  19.         printMethod.Invoke(instance, null);
  20.     }
  21. }
复制代码

在这个示例中，首先获取了泛型范例的定义 MyGenericClass<>，然后指定了详细的泛型范例参数，比方 int。接着使用 MakeGenericType 创建了指定参数的泛型范例实例，并通过 Activator.CreateInstance 创建了实例对象。最后，使用反射调用了泛型范例的方法。

  1. using System;
  2. using System.Reflection;
  4. class Program
  5. {
  6.     static void Main(string[] args)
  7.     {
  8.         // 通过反射查找类型
  9.         Type type = Type.GetType("Demo.Person");
  11.         // 通过反射创建对象
  12.         object person = Activator.CreateInstance(type);
  14.         // 通过反射调用方法
  15.         MethodInfo methodInfo = type.GetMethod("SayHello");
  16.         methodInfo.Invoke(person, null);
  18.         // 通过反射获取属性
  19.         PropertyInfo propertyInfo = type.GetProperty("Name");
  20.         Console.WriteLine("Name: {0}", propertyInfo.GetValue(person));
  22.         // 通过反射修改属性
  23.         propertyInfo.SetValue(person, "Tom", null);
  24.         Console.WriteLine("Name: {0}", propertyInfo.GetValue(person));
  26.         // 通过反射获取字段
  27.         FieldInfo fieldInfo = type.GetField("Age");
  28.         Console.WriteLine("Age: {0}", fieldInfo.GetValue(person));
  30.         // 通过反射修改字段
  31.         fieldInfo.SetValue(person, 20);
  32.         Console.WriteLine("Age: {0}", fieldInfo.GetValue(person));
  33.     }
  34. }
  36. class Person
  37. {
  38.     public string Name { get; set; }
  39.     public int Age;
  41.     public void SayHello()
  42.     {
  43.         Console.WriteLine("Hello, my name is {0}.", Name);
  44.     }
  45. }
复制代码
在这个示例中，我们通过反射查找了一个名为Demo.Person的范例，并创建了一个该范例的对象。然后，我们使用反射获取了该对象的SayHello方法，并通过Invoke方法调用了该方法。接着，我们使用反射获取了该对象的Name属性，并获取了该属性的值。然后，我们通过反射修改了该对象的Name属性的值，并再次获取了该属性的值。最后，我们使用反射获取了该对象的Age字段，并获取了该字段的值。然后，我们通过反射修改了该对象的Age字段的值，并再次获取了该字段的值。
·使用反射调用构造器，可以通过以下步调实现：
通过Type.GetType方法大概typeof关键字获取目标范例的Type对象。比方，获取Demo.Person范例的Type对象可以使用以下代码：Type type = Type.GetType("Demo.Person"); 大概 Type type = typeof(Demo.Person);




Activator.CreateInstance和constructor.Invoke都可以用于创建对象，但它们的实现方式有所差别。
Activator.CreateInstance是一个静态方法，它使用指定的范例名、程序集名、参数等信息来创建一个实例。它可以自动选择适当的构造函数进行创建，并且支持泛型范例的创建。使用Activator.CreateInstance可以避免手动获取构造函数的过程，让创建对象的过程更加简便。但是，由于其通过字符串来指定范例名和程序集名，因此需要在编译时指定完整的范例名和程序集名，不太方便动态获取范例。
constructor.Invoke则是使用反射获取到一个构造函数后，通过Invoke方法来调用构造函数，创建一个对象。与Activator.CreateInstance相比，使用constructor.Invoke需要手动获取构造函数，需要明确指定构造函数的参数，因此相对来说更加复杂。但是，它可以在运行时动态获取范例和构造函数，更加灵活。
总的来说，Activator.CreateInstance实用于已知范例名和程序集名的情况，可以让创建对象更加简便；而constructor.Invoke实用于需要动态获取范例和构造函数的情况，更加灵活。









免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4