【C#】解析C#程序集的加载和反射

目录结构：

contents structure [+]

1. 程序集
1. 程序集的加载
2. 发现程序集中的类型
2. 反射对类型成员的常规操作
1. 发现类型的成员
2. 创建类型的实例
3. 绑定句柄减少进程的内存消耗
3. 解析自定义特性

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;
        }
    }