C#的反射（一）
1.什么是元数据（MetaData）和反射（reflection）
一般情况下我们的程序都在处理数据的读、写、操作和展示。但是有些程序操作的数据不是数字、文本、图片，而是程序和程序类型本身的信息。
①元数据是包含程序以及类型信息的数据，它保存在程序的程序集当中。
②程序在运行的时候，可以查看其他程序集或者其本身的元数据。这个行为就是反射。
2.Type类
BCL声明了一个Type类型（它是抽象类），用来包含类型的特性。使用这个类的对象能让我们获取程序使用的类型的信息。
由于Type是抽象类，所以它不能被实例化。而是在运行时，CLR创建从Type（RuntimeType）派生的类型的实例。当我们要访问这些实例的时候，CLR不会返回派生类的引用而是返回Type基类的引用。
关于Type有如下重要的点：
①对于程序每一个需要用到的类型，CLR会穿件一个包含这个类型信息的Type类型的对象（真实的是上面说的派生的类型的实例）。
②程序中用到的每一个类型都会关联到独立的Type类的对两个象。
③无论创建的类型有多少个实例，只有一个Type对象会关联到所有这些实例。就像下面的图表示的一样。创建了一个OtherClass的实例oc、以及两个MyClass的实例mc1和mc2，但是在堆上都只会有一个Type对象来的对应他们，如下面的图示：
简单看一下Type这个类型，里面可以看到如下的一些方法和属性。
官方文档更全面哦： https://docs.microsoft.com/zh-cn/dotnet/api/system.type?view=netframework-4.8
3.学习如何获取一个Type类对象
方法一：通过GetType方法
object类型包含了一个GetType方法，它可以用来返回事例的Type对象引用。由于所有的类都是继承自object类型，所以所有的类都可以调用GetType来获得Type类型对象的引用。下面的图很好的说明了，基类、派生类和object之间的关系
所以下面的代码，在遍历派生类的Field的时候才能，把基类的也输出出来。
//基类 class BaseClass { public int BaseField = 0; } //派生类 class DerivedClass : BaseClass { public int DerivedField = 0; } class Program { static void Main(string[] args) { var bc = new BaseClass(); var dc = new DerivedClass(); BaseClass[] bca = new BaseClass[] { bc, dc }; foreach(var v in bca) { //获取类型 Type t = v.GetType(); Console.WriteLine("Object Type: {0}", t.Name); //获取类中的字段 FieldInfo[] fi = t.GetFields(); foreach (var f in fi) Console.WriteLine(" Field:{0}", f.Name); Console.WriteLine(); } Console.WriteLine("End!"); Console.ReadKey(); } }
结果：
Object Type: BaseClass
Field:BaseField
Object Type: DerivedClass
Field:DerivedField
Field:BaseField
End!
方法二：还可以通过typeof()方法来获取一个类型的Type对象引用。例如下面的代码：
Type t = typeof(DerivedClass);
此外我们可以根据程序集来获取程序集内的类型
//通过程序集获取类型
var baseType = Assembly.GetExecutingAssembly().GetType("TestDemo.BaseClass");
var derivedType = Assembly.GetExecutingAssembly().GetType("TestDemo.DerivedClass");
4.常用的操作
结合GetType和typeof操作，可以做很多事情。
①获取数组类型
static void Main(string[] args) { var intArray = typeof(int).MakeArrayType(); var int3Array = typeof(int).MakeArrayType(3); Console.WriteLine($"是否是int 数组 intArray == typeof(int[]) ：{intArray == typeof(int[]) }"); Console.WriteLine($"是否是int 3维数组 intArray3 == typeof(int[]) ：{int3Array == typeof(int[]) }"); Console.WriteLine($"是否是int 3维数组 intArray3 == typeof(int[,,])：{int3Array == typeof(int[,,]) }"); //数组元素的类型 Type elementType = intArray.GetElementType(); Type elementType2 = int3Array.GetElementType(); Console.WriteLine($"{intArray}类型元素类型：{elementType }"); Console.WriteLine($"{int3Array}类型元素类型：{elementType2 }"); //获取数组的维数 var rank = int3Array.GetArrayRank(); Console.WriteLine($"{int3Array}类型维数：{rank }"); Console.ReadKey(); }
如上面的例子，
MakeArrayType() 可以用来获取数组类型，有一个参数是数组的维数
GetElementType() 可以用来获取数组元素的类型
GetArrayRank() 可以获取数组的维数
②获取嵌套类型
public class Class { public class Student { public string Name { get; set; } } } class Program { static void Main(string[] args) { #region 嵌套类型 var classType = typeof(Class); foreach (var t in classType.GetNestedTypes()) { Console.WriteLine($"NestedType ={t}"); //获取一个值，该值指示 System.Type 是否声明为公共类型。 Console.WriteLine($"{t}访问 {t.IsPublic}"); //获取一个值，通过该值指示类是否是嵌套的并且声明为公共的。 Console.WriteLine($"{t}访问 {t.IsNestedPublic}"); } Console.ReadKey(); #endregion } }
输出：
NestedType =TestDemo.Class+Student TestDemo.Class+Student访问 False TestDemo.Class+Student访问 True
③获取类型名称
Type里面具有NameSpace、Name和FullName属性。一般FullName是两者的组合。但是对于嵌套类型和封闭式泛型不成立。可以参考下面的demo
static void Main(string[] args) { #region 获取名称 var type = typeof(Class); Console.WriteLine($"\n------------一般类型-------------"); PrintTypeName(type); //嵌套类型 Console.WriteLine($"\n------------嵌套类型-------------"); foreach (var t in type.GetNestedTypes()) { PrintTypeName(t); } var type2 = typeof(Dictionary<,>); //非封闭式泛型 var type3 = typeof(Dictionary<string, int>); //封闭式泛型 Console.WriteLine($"\n------------非封闭式泛型-------------"); PrintTypeName(type2); Console.WriteLine($"\n------------封闭式泛型-------------"); PrintTypeName(type3); Console.ReadKey(); #endregion } private static void PrintTypeName(Type t) { Console.WriteLine($"NameSpace: {t.Namespace}"); Console.WriteLine($"Name :{t.Name}"); Console.WriteLine($"FullName: {t.FullName}"); }
结果：
------------一般类型------------- NameSpace: TestDemo Name :Class FullName: TestDemo.Class ------------嵌套类型------------- NameSpace: TestDemo Name :Student FullName: TestDemo.Class+Student NameSpace: TestDemo Name :Teacher FullName: TestDemo.Class+Teacher ------------非封闭式泛型------------- NameSpace: System.Collections.Generic Name :Dictionary`2 FullName: System.Collections.Generic.Dictionary`2 ------------封闭式泛型------------- NameSpace: System.Collections.Generic Name :Dictionary`2 FullName: System.Collections.Generic.Dictionary`2[ [System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089], [System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
④获取基类类型和接口类型
var base1 = typeof(System.String).BaseType; var base2 = typeof(System.IO.FileStream).BaseType; var base3 = typeof(DerivedClass).BaseType; Console.WriteLine($"base1 :{base1.Name}"); Console.WriteLine($"base2 :{base2.Name}"); Console.WriteLine($"base3 :{base3.Name}"); foreach (var iType in typeof(Guid).GetInterfaces()) { Console.WriteLine($"iType :{iType.Name}"); }
输出：
base1 :Object base2 :Stream base3 :BaseClass iType :IFormattable iType :IComparable iType :IComparable`1 iType :IEquatable`1
此外Type还有两个方法：
我们在判断某个实例对象是否是某个类型的时候，经常使用 is语句。
Type中的方法 IsInstanceOfType 其实和is是等价的。
var baseClassObject = new BaseClass();
var check1 = baseClassObject is BaseClass;
var check2 = base3.IsInstanceOfType(baseClassObject);
Console.WriteLine($"使用is判断类型是否相同 :{check1}"); //结果True
Console.WriteLine($"使用IsInstanceOfType类型是否相同 :{check2 }"); //结果True
返回结果都是True的。
还有一个是 IsAssignableFrom ，它的作用是确定指定类型的实例是否可以分配给当前类型的实例。
var base4 = typeof(BaseClass); //baseClass的实例
var baseClassObject = new BaseClass();
var derivedClassObject = new DerivedClass();
var classObject = new Class();
var checkResult1 = base4.IsAssignableFrom(baseClassObject.GetType()); //判断BaseClass类型是否可以分配给BassClass类型
var checkResult2 = base4.IsAssignableFrom(derivedClassObject.GetType()); //判断DerivedClass类型是否可以分配给BassClass类型
var checkResult3 = base4.IsAssignableFrom(classObject.GetType()); //判断Class类型是否可以分配给BassClass类型
Console.WriteLine($"使用IsAssignableFrom类型是否和接受的类型一致 :{checkResult1}"); //True
Console.WriteLine($"使用IsAssignableFrom类型是否和接受的类型一致 :{checkResult2}"); //True
Console.WriteLine($"使用IsAssignableFrom类型是否和接受的类型一致 :{checkResult3}"); //False
⑤实例化类型
I. 有两种方法可以动态的实例化类型。
方法一 通过静态的 Activator.CreateInstance()方法创建，它有多个重载函数。
var dateTime1 = (DateTime)Activator.CreateInstance(typeof(DateTime),2019,6,19);
var dateTime2 = (DateTime)Activator.CreateInstance(typeof(DateTime), 2019,6,19,10,10,10);
Console.WriteLine($"DateTime1: {dateTime1}"); //DateTime1: 2019/6/19 0:00:00
Console.WriteLine($"DateTime2: {dateTime2}"); //DateTime2: 2019/6/19 10:10:10
一般我们像上面一样都是传一个Type和构造函数的参数。当不存在这个构造函数的时候，就会抛出错误。
方法二 调用ConstructInfo对象上面的Invoke方法，ConstructInfo对象是通过调用类型（高级环境）上的GetConstructor方法获取的。
先分析一下场景，例如我有下面这样的一个类型：
public class InvokeClass { private string _testString; private long _testInt; public InvokeClass(string abc) { _testString = abc; } public InvokeClass(StringBuilder abc) { _testString = abc.ToString(); } public InvokeClass(string abc,long def) { _testString = abc; _testInt = def; } }
存在两个构造函数，一个传入的是string类型，一个传入的是StringBuilder类型，此时如果我通过new 的方式去创建一个对象，并传入构造函数为null，那么就是报出下面的错误：说明存在二义性，也就是说找不到对应使用哪个来构造。
同样的，如果我使用方法一 Activator.CreateInstance 去创建对象，会出现下面的问题：找不到对应的构造函数。
但是采用ConstructInfo的方式就可以指定对应的构造函数了。类似如下代码
//找到一个参数为string的构造函数
var constructorInfo = typeof(InvokeClass).GetConstructor(new[] { typeof(string)});
//使用该构造函数传入一个null参数
var obj4 = (InvokeClass)constructorInfo.Invoke(new object[] { null });
还可以结合查询来找到对应的构造函数
//获取所有的构造函数
var constructorInfoArray = typeof(InvokeClass).GetConstructors();
//过滤一次，获取所有两个参数的构造函数
var constructorInfoArray2 = Array.FindAll(constructorInfoArray, x => x.GetParameters().Length == 2);
//最后找的第二个参数是long类型的构造函数
var constructorInfo2 = Array.Find(constructorInfoArray2, x => x.GetParameters()[1].ParameterType == typeof(long));
//如果存在，就创建对象
if (constructorInfo2 != null)
{
var obj5 = (InvokeClass)constructorInfo2.Invoke(new object[] { "abc", 123 });
}
动态构造对象的缺点就是慢，简单对比一下，采用反射和new创建100万个对象，耗时对比还是比较明显的。
var sw = new Stopwatch(); sw.Start(); for (int i = 0; i < 100000; i++) { var obj3 = (InvokeClass)Activator.CreateInstance(typeof(InvokeClass), "abc", 123); } sw.Stop(); Console.WriteLine($"时间：{sw.ElapsedMilliseconds}ms"); var sw2 = new Stopwatch(); sw2.Start(); for (int i = 0; i < 100000; i++) { var obj = new InvokeClass("abc", 123); } sw2.Stop(); Console.WriteLine($"时间：{sw2.ElapsedMilliseconds}ms");
输出:
时间：280ms
时间：1ms
II. 实例化委托
动态创建静态方法和实例方法的委托传入的参数不太一样，使用的是CreateDelegate的重载，可以参考下面的例子
/// <summary> /// 创建指定类型的委托，该委托表示要对指定的类实例调用的指定实例方法。 /// </summary> /// <param name="type">要创建的委托的 System.Type</param> /// <param name="target"> 类实例，对其调用 method</param> /// <param name="method">委托要表示的实例方法的名称</param> /// <returns></returns> public static Delegate CreateDelegate(Type type, object target, string method); /// <summary> /// 创建指定类型的委托，该委托表示指定类的指定静态方法。 /// </summary> /// <param name="type">要创建的委托的 System.Type</param> /// <param name="target"> 表示实现 method 的类的 System.Type</param> /// <param name="method"> 委托要表示的静态方法的名称。</param> /// <returns></returns> public static Delegate CreateDelegate(Type type, Type target, string method);
例如：
class Program { public static int StaticSum(int a, int b) { return a + b; } public int InstanceSum(int a, int b) { return a + b; } //创建一个委托 delegate int delegateOperate(int a, int b); static void Main(string[] args) { #region 实例化委托 //静态方法的委托 Delegate staticD = Delegate.CreateDelegate(typeof(delegateOperate), typeof(Program), "StaticSum"); //实例方法的委托 Delegate instanceD = Delegate.CreateDelegate(typeof(delegateOperate), new Program(), "InstanceSum"); Console.WriteLine($"staticD：{staticD.DynamicInvoke(1,2)}"); Console.WriteLine($"instanceD：{instanceD.DynamicInvoke(10,20)}"); #endregion Console.ReadKey(); } }
III.范型的实例化
泛型分为封闭型和未封闭型，对于封闭类型的泛型是可以通过反射进行实例化的，而未封闭的泛型不能实例化。如下图所示：
封闭式的泛型和未绑定的泛型是可以相互转换的。
①未绑定的泛型可以通过 MakeGenericType 变成封闭的
②封闭的可以通过GetGenericTypeDefinition 获取未绑定的类型。
class Program { static void Main(string[] args) { Type closed = typeof(List<int>); Type unBound = typeof(List<>); //转换 var newClosed = unBound.MakeGenericType(typeof(int)); var newUnBound = closed.GetGenericTypeDefinition(); Console.WriteLine($"List<int> 类型{closed}"); Console.WriteLine($"List<> 类型{unBound}"); Console.WriteLine($"List<> MakeGenericType执行后 类型{newClosed}"); Console.WriteLine($"List<int> GetGenericTypeDefinition执行后 类型{newUnBound}"); } }
参考： 《C#图解教程》、《果壳中的C#》
