【C#】解析C#程序集的加载和反射
目录结构：
1.程序集
1.1 程序集的加载
想必读者对程序集并不陌生吧，在这里笔者结合反射来阐述程序集的加载。如果想要动态加载程序集，那么就要使用System.Reflection.Assembly类。
程序集加载最常用的静态方法是：
public static Assembly Load(string assemblyString) public static Assembly LoadFrom(string assemblyFile)
使用Load方法加载程序集必须传递程序集的全名称，程序集的全名称由四个部分组成（程序集的简单名称、程序集的版本、程序集的语言文化，程序集的公钥标记）。程序集的实例属性FullName就是程序集的全名称。LoadFrom方法允许从本地和远程网络加载程序集，在通过远程网络加载的是时候需要注意，不能通过FTP协议远程加载程序集。
如果只想通过反射来分析程序集中的元数据，并希望程序集中的任何代码都不会被执行，那么在加载程序集的时候最好使用Assembly的ReflectionOnlyLoad方法或是ReflectionOnlyLoadFrom方法。如下：
public static Assembly ReflectionOnlyLoad(string assemblyString) public static Assembly ReflectionOnlyLoadFrom(string assemblyFile)
除了使用Assembly类来加载程序集之外，还可以利用System.AppDomain类的实例方法public Assembly Load(string assemblyString)来完成。该实例方法有许多重载版本，这里需要注意，由于Assembly不是派生自MarshalByRefObject类，所以使用Load方法得到的程序集是按值封送。
如下：
如果代表当前AppDomain的域为A，Load方法调用在AppDomain域B中，那么被Load加载的程序集会被域A和域B都加载。
AppDomain ad = AppDomain.CreateDomain("ChildDomain"); ad.Load("MyAssembly");
这段代码中，MyAssembly程序集将会被加载到两个AppDomain中，一个是运行代码所在的AppDomain，另一个是新创建的AppDomain。这是因为Assembly是按值封送的，所以CLR将会在调用线程的AppDomain中重新加载程序集。
1.2 发现程序集中的类型
在上面的一节中，我们知道了如何加载一个程序集，接下来就是要探索程序集中的类型。
如下：
class Program { static void Main(string[] args) { Assembly assembly = Assembly.Load("System.Data,Version=4.0.0.0,Culture=neutral,PublicKeyToken=b77a5c561934e089"); foreach (Type type in assembly.GetExportedTypes()) { Console.WriteLine(type.FullName); } Console.ReadLine(); } }
这里笔者加载了System.Data程序集，System.Data程序集是被安装到GAC中的。
GetExportedTypes()返回程序集中由public定义的类型，该方法返回和ExportedTypes属性的含义相同。
2.反射对成员的常规操作
2.1 发现类型的成员
字段、构造器、方法、属性、事件和嵌套类型都可以定义为类型成员。FCL包含了抽象基类System.Reflection.MemberInfo，封装了类型成员的通用属性。MemberInfo有许多派生类，这些类型的层次结构如下：
System.Type 类对于反射起着核心的作用。但它是一个抽象的基类，Type有与每种数据类型对应的派生类，我们使用这个派生类的对象的方法、字段、属性来查找有关该类型的所有信息。
获取给定类型的Type引用有3种常用方式：
使用 C# typeof 运算符。
Type t = typeof(string);
使用对象GetType()方法。
string s = "grayworm"; Type t = s.GetType();
还可以调用Type类的静态方法GetType()。
Type t = Type.GetType("System.String");
除了System.Type类还有一个类是在反射中经常需要使用的，就是BindingFlags。BindingFlags是一个枚举类，经常需要用的枚举值为BindingFlags.Public,BindFlags.NonPublic,BindFlags.Instance,BindFlags.Static，关于这些值的详细含义和更多信息可以参考官方文档。
上面这三类代码都是获取string类型的Type，在取出string类型的Type引用t后，我们就可以通过t来探测string类型的结构了。
string n = "grayworm"; Type t = n.GetType(); foreach (MemberInfo mi in t.GetMembers()) { Console.WriteLine("{0}/t{1}",mi.MemberType,mi.Name); }
查看类中的构造方法
NewClassw nc = new NewClassw(); Type t = nc.GetType(); ConstructorInfo[] ci = t.GetConstructors(); //获取类的所有构造函数 foreach (ConstructorInfo c in ci) //遍历每一个构造函数 { ParameterInfo[] ps = c.GetParameters(); //取出每个构造函数的所有参数 foreach (ParameterInfo pi in ps) //遍历并打印所该构造函数的所有参数 { Console.Write(pi.ParameterType.ToString()+" "+pi.Name+","); } Console.WriteLine(); }
用构造函数动态生成对象
Type t = typeof(NewClassw); Type[] pt = new Type[2]; pt[0] = typeof(string); pt[1] = typeof(string); //根据参数类型获取构造函数 ConstructorInfo ci = t.GetConstructor(pt); //构造Object数组，作为构造函数的输入参数 object[] obj = new object[2]{"grayworm","hi.baidu.com/grayworm"}; //调用构造函数生成对象 object o = ci.Invoke(obj); //调用生成的对象的方法测试是否对象生成成功 //((NewClassw)o).show();
类的属性(Property)
NewClassw nc = new NewClassw(); Type t = nc.GetType(); PropertyInfo[] pis = t.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); foreach(PropertyInfo pi in pis) { Console.WriteLine(pi.Name); }
查看类中的方法（Method）
NewClassw nc = new NewClassw(); Type t = nc.GetType(); MethodInfo[] mis = t.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);//这里获得的只是获得实例的public和非public修饰的方法，要获得所有的方法，参照上面的获取属性的代码，指定标识符就可以了 foreach (MethodInfo mi in mis) { Console.WriteLine(mi.ReturnType+" "+mi.Name); }
查看类的字段 (Field)
NewClassw nc = new NewClassw(); Type t = nc.GetType(); FieldInfo[] fis = t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); foreach (FieldInfo fi in fis) { Console.WriteLine(fi.Name); }
用反射生成对象，并调用属性、方法和字段进行操作
NewClassw nc = new NewClassw(); Type t = nc.GetType(); Type[] pt = new Type[2]; pt[0] = typeof(string); pt[1] = typeof(string); //根据参数类型获取构造函数 ConstructorInfo ci = t.GetConstructor(pt); //构造Object数组，作为构造函数的输入参数 object[] objpara = new object[2]{"grayworm","hi.baidu.com/grayworm"}; //调用构造函数生成对象 object obj = ci.Invoke(objpara); //取得ID字段 FieldInfo fi = t.GetField("ID",BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); //给ID字段赋值 fi.SetValue(obj, "k001"); //取得MyName属性 PropertyInfo pi1 = t.GetProperty("MyName",BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); //给MyName属性赋值 pi1.SetValue(obj, "grayworm", null); PropertyInfo pi2 = t.GetProperty("MyInfo"); pi2.SetValue(obj, "hi.baidu.com/grayworm", null); //取得show方法 MethodInfo mi = t.GetMethod("show"); //调用show方法 mi.Invoke(obj, null);
2.2 创建类型的实例
在上面介绍类型成员的时候，已经使用类型的构造方法创建过类型的实例了。接下来，进行总结一下：
a.System.Activator的CreateInstance方法。
b.System.Activator的CreateInstanceFrom方法。
c.System.AppDomain的方法
AppDomain类型提供了4个用于构造类型实例的实例方法，包括CreateInstance,CreateInstanceAndUnwrap,CreateInstanceFrom和CreateInstanceFromAndUnwrap方法。
CreateInstance提供了几个重载版本，每个重载版本都返回了一个ObjectHandle类对象。通过调用ObjectHandler的Unwrap就可以得到实例对象。而CreateInstanceAndUnwrap方法，简化了这步操作，该方法返回了一个Object对象。
d.System.Reflection.ConstructorInfo的Invoke方法。
上面列出的机制，可以为除了数组（System.Array派生的类型）和委托（System.MulticastDelegate派生的类型）之外的所有的类型创建类型实例。
创建数组对象，需要使用Array的静态CreateInstance方法。创建委托对象，需要使用MethodInfo的静态CreateDelegate方法。
构造泛型类型的实例，和构造普通实例类型的代码差不多，只是复杂一点而已。构造泛型类型实例的时候，需要使用Type类的MakeGenericType方法创建泛型类型参数。
例如：
class Program { static void Main(string[] args) { //获取对泛型类型的类型对象的引用 Type openType=typeof(Dictionary<,>); //使用TKey=String,TValue=Int32封闭泛型类型 Type closedType = openType.MakeGenericType(typeof(String),typeof(Int32)); //构造封闭类型的实例 Object o = Activator.CreateInstance(closedType); Console.WriteLine(o.GetType()); Console.ReadLine(); } }
2.3 绑定句柄减少进程的内存消耗
如果在应用程序中需要绑定一组类型（Type对象）或类型成员（MemberInfo派生对象），并将这些对象保存在某种形式的集合中。以后，应用程序搜索这个集合，查找特定对象，然后调用对象。这种机制很好，但是有个小问题：Type对象和MemberInfo对象都需要大量内存。如果应用程序容纳了太多这样的对象，但只是偶尔使用，应用程序消耗的内存就会急剧上升，这样会对应用程序产生反面影响。
CLR内部是更精简的方式表示这种信息。CLR之所以为引用程序创建这些对象，只是为了方便开发人员。如果需要保存/缓存大量Type和MemberInfo派生对象，开发人员可以使用运行时句柄代替对象减少工作集（占用的内存）。FCL定义了三个运行时句柄对象，包括RuntimeTypeHandle,RuntimeFieldHandle和RuntimeMethodHandle。这三个都是轻量级别的句柄类型，因此如果需要大量缓存Type对象和MemberInfo派生对象，可以考虑使用轻量级的句柄对象。
将Type对象转化为RuntimeTypeHandle，调用Type的静态GetTypeHandle方法并且传递那个Type对象的引用。
将RumtimeTypeHandle转化为Type对象，调用Type的静态方法GetTypeFromHandle，并传递那个RuntimeTypeHandle。
将FieldInfo对象转化为RuntimeFieldHandle,调用FieldInfo的只读实例属性FieldHandle。
将RuntimeFieldHandle转化为FieldInfo对象，调用FieldInfo的静态方法GetFieldFromHandle方法。
将MethodInfo对象转化为RuntimeMethodHandle，调用MethodInfo的只读实例属性MethodHandle。
将RuntimeMethodHandle转化为MethodInfo对象，调用MethodInfo的静态方法GetMethodFromHandle方法。
例如：
class Program { private const BindingFlags c_bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static; static void Main(string[] args) { List<MethodBase> methodInfos=new List<MethodBase>(); foreach (Type t in typeof(Object).Assembly.GetExportedTypes()) { if (t.IsGenericTypeDefinition) continue; methodInfos.AddRange(t.GetMethods(c_bf)); } //绑定所有方法后，显示方法的个数 Console.WriteLine("# of methods = {0}",methodInfos.Count); Show("After building cache of MethodInfo objects"); List<RuntimeMethodHandle> methodHandles= methodInfos.ConvertAll<RuntimeMethodHandle>(mb => { return mb.MethodHandle; }); Show("Holding MethodInfo and RuntimeMethod Catch"); GC.KeepAlive(methodInfos);//阻止缓存被过早回收 methodInfos = null; Show("After free methodInfo object"); methodInfos = methodHandles.ConvertAll<MethodBase>(mrh => { return MethodBase.GetMethodFromHandle(mrh); }); Show("size of heap after re-creating MethodInfo objects"); GC.KeepAlive(methodInfos);//阻止缓存被过早回收 GC.KeepAlive(methodHandles);//阻止缓存被过早回收 methodInfos = null; methodHandles = null; Show("After freeing both methodInfo and methodHandles"); Console.ReadLine(); } static void Show(String s) { Console.WriteLine("Heap size={0:N12} - {1}",GC.GetTotalMemory(true),s); } }
输出如下：
# of methods = 36572
Heap size=3,881,636.000000000000 - After building cache of MethodInfo objects
Heap size=4,028,180.000000000000 - Holding MethodInfo and RuntimeMethod Catch
Heap size=4,028,140.000000000000 - After free methodInfo object
Heap size=3,994,152.000000000000 - size of heap after re-creating MethodInfo objects
Heap size=153,128.000000000000 - After freeing both methodInfo and methodHandles
3.解析自定义特性
为了简便编程，我们往往需要自定义特性，在程序中可以通过反射获得特性的相关信息。
例如：
class Program { [MyTag("test")] public void init() { } static void Main(string[] args) { Type cp= typeof(Program); //获得指定的方法 MethodInfo method= cp.GetMethod("init",System.Reflection.BindingFlags.Public|System.Reflection.BindingFlags.NonPublic|System.Reflection.BindingFlags.Instance); //获得特性 MyTag attr = method.GetCustomAttribute(typeof(MyTag)) as MyTag; Console.WriteLine(attr.value); Console.ReadLine(); } } [AttributeUsage(AttributeTargets.Method, Inherited = true)] class MyTag : System.Attribute { public string value = String.Empty; public MyTag(String info) { this.value = info; } }
