首先了解C#反射的概念，反射是一个运行库类型发现的过程。通过反射可以得到一个给定程序集所包含的所有类型的列表，
  
    这个列表包括给定类型中定义的方法、字段、属性和事件。也可以动态的发现一组给定类支持的借口、方法的参数和其他
  
    相关信息如基类、命名空间、数据清单等。
  
    C#反射命名空间详细介绍：
  
    1.System.Reflection命名空间内的各类型
  
    （1） Assembly通过它可以加载、了解和操纵一个程序集
  
    （2） AssemblyName 通过它可以找到大量隐藏在程序集的身份中的信息，如版本信息、区域信息等
  
    （3） EventInfo 事件的信息
  
    （4） FieldInfo 字段的信息
  
    （5） MethodInfo 方法的信息
  
    （6） ParameterInfo 参数的信息
  
    （7） PropertyInfo 属性的信息
  
    （8） MemberInfo 是抽象基类，为 EventInfo、FieldInfo 、MethodInfo、PropertyInfo等类型定义了公共的行为。
  
    （9） Module 用来访问带有多文件程序集的给定模块
  
    2.System.Type类
  
    System.Type支持的成员可以分为这样几类
  
    （1） Is*** 用来检查一个类型的元数据，如IsAbstract、IsClass、IsValueType等等
  
    （2） Get*** 用来从类型得到指定项目，如GetEvent（）得到类型的一个指定的事件（EventInfo）。
  
    另外，这些方法都有一个单数版本和一个复数版本。如GetEvent（）对应有一个复数版本GetEvents（），
  
    该方法返回一个相关的EventInfo数组。
  
    （3） FindMembers（） 根据查询条件返回一个MemberInfo类型的数组
  
    （4）GetType（） 该静态方法根据一个字符串名称返回一个Type实例
  
    （5）InvokeMember（） 对给定项目进行晚期绑定
  
    3.得到一个Type类型实例的三种方法
  
    因为Type是一个抽象类，所以不能直接使用new关键字创建一个Type对象
  
    （1）使用System.Object.GetType（）
  
    Person pe=new Person（）； //---------定义pe为person类的一个对象
  
    Type t=pe.GetType（）；
  
    （2）使用System.Type.GetType（）静态方法，参数为类型的完全限定名
  
    Type t=Type.GetType（"Entity.Person"）； 该方法被重载，允许指定两个布尔类型的参数，一个用来控制当前类型不能找到时是否抛出异常，
  
    另一个用来指示是否区分字符串大小写
  
    Type t=Type.GetType（"Entity.Person",false,true）； 注意到传入的字符串并没有包含类型所在的程序集信息，此时该类型便被认为是定义在当前执行的程序集中的。
  
    要得到一个外部私有程序集的类型元数据时，字符串参数必须使用类型完全限定名加上类型所在程序集的友好名字
  
    Type t=Type.GetType（"Entity.Person","Entity"）； //------"Entity"即为类型所在程序集的友好名字 嵌套类型：传入的字符串可以指定一个+标记来表示一个嵌套类型，
  
    如希望得到一个嵌套在person类中的枚举类型City的类型信息，则可以这样
  
    Type t=Type.GetType（"Entity.person+City"）；
  
    （3）使用typeof运算符
  
    Type t=typeof（person）； 三种方法的比较：
  
    使用第一种方法必须先建立一个实例，而后两种方法不必先建立实例。但使用typeof运算符仍然需要知道类型的编译时信息，
  
    而使用System.Type.GetType（）静态方法不需要知道类型的编译时信息，所以是首选方法。
  
    一个最简单的C#反射实例，首先编写类库如下：
  
    namespace ReflectionTest
  
    {
  
    public class WriteTest
  
    {
  
    //带参数的公共方法
  
    public void WriteString（string s, int i）
  
    {
  
    Console.WriteLine（"WriteString:" + s + i.ToString（））；
  
    }
  
    //带一个参数的静态方法
  
    public static void StaticWriteString（string s）
  
    {
  
    Console.WriteLine（"StaticWriteString:" + s）；
  
    }
//不带参数的静态方法
  
    public static void NoneParaWriteString（）
  
    {
  
    Console.WriteLine（"NoParaWriteString"）；
  
    }
  
    }
  
    }
  
    class TestApp
  
    {
  
    public static void Main（）
  
    {
  
    Assembly ass;
  
    Type type;
  
    Object obj;
  
    //用来测试静态方法
  
    Object any = new Object（）；
  
    //指定类库文件必须使用绝对路径，不能使用相对路径
  
    ass = Assembly.LoadFile（@"D:\Source Code\00.C#Sudy\01.Reflection\01\ReflectTest.dll"）；
  
    //命名空间和类的名字必须一起指定
  
    type = ass.GetType（"ReflectionTest.WriteTest"）；
  
    /**//*example1---------*/
  
    MethodInfo method = type.GetMethod（"WriteString"）；
  
    string test = "test";
  
    int i = 1;
  
    Object[] parametors = new Object[]{test,i};
  
    //在例子1种必须实例化反射要反射的类，因为要使用的方法并不是静态方法。
  
    //创建对象实例
  
    obj = ass.CreateInstance（"ReflectionTest.WriteTest"）；
  
    //执行带参数的公共方法
  
    method.Invoke（obj, parametors）；
  
    //method.Invoke（any, parametors）；//异常：必须实例化反射要反射的类，因为要使用的方法并不是静态方法。
  
    /**//*example2----------*/
  
    method = type.GetMethod（"StaticWriteString"）；
  
    method.Invoke（null, new string[] { "test"}）； //第一个参数忽略
  
    //对于第一个参数是无视的，也就是我们写什么都不会被调用，
  
    //即使我们随便new了一个any这样的Object,当然这种写法是不推荐的。
  
    //但是对应在例子1种我们如果Invoke的时候用了类型不一致的实例来做为参数的话，将会导致一个运行时的错误。
  
    method.Invoke（obj, new string[] { "test"}）；
  
    method.Invoke（any, new string[] { "test"}）；
  
    /**//*example3-----------*/
  
    method = type.GetMethod（"NoneParaWriteString"）； //调用无参数静态方法的例子，这时候两个参数我们都不需要指定，用null就可以了。s
  
    method.Invoke（null, null）；
  
    }
  
    }
  
    从上面的总结中可以看出，对于外部调用的动态库应用反射时要用到Assembly.LoadFile（），然后才是获取类型、执行方法等；
  
    当用反射创建当前程序集中对象实例或执行某个类下静态方法时只需通过Type.GetType（"类的完整名"）。