首先说说，为什么要学习 反射 呢？有什么用啊。

 在我们写程序的时候，经常会用到一些类中的方法，那么就要调用这些个类。如果不是在一个命名空间里时，就要引用相应的dll文件，然后再读取类中的方法。可是这样一来就很麻烦，因为记不住所有的类的地址啊，使用很不方便。

这时候就体现出反射了，我们不知道类在哪里，但是依然可以使用，只要知道名字，通过反射就可以得到地址信息，进行调用。

反射可以动态的创建类型实例，再绑定到现有对象上。

从特定的程序集里载入特定的类型，以创建特定的实例。

反射的特性就是动态的建立实例，但是它的弊端就是要牺牲一些性能，并且有些属性信息是不能通过反射来得到的。

反射 是.Net中获取运行时类型信息的方式，.Net的应用程序由几个部分：‘程序集(Assembly)’、‘模块(Module)’、‘类型(class)’组成，而反射提供一种编程的方式，让程序员可以在程序运行期获得这几个组成部分的相关信息，例如：     

Assembly类可以获得正在运行的装配件信息，也可以动态的加载装配件，以及在装配件中查找类型信息，并创建该类型的实例。

所有要素：方法、构造器、属性等等，通过Type类可以得到这些要素的信息，并且调用之。

Type类可以获得对象的类型信息，此信息包含对象的MethodInfo包含方法的信息，通过这个类可以得到方法的名称、参数、返回值等，并且可以调用之。

诸如此类，还有FieldInfo、EventInfo等等，这些类都包含在System.Reflection命名空间下。

命名空间与装配件的关系

        很多人对这个概念可能还是很不清晰，对于合格的.Net程序员，有必要对这点进行澄清。

        命名空间类似与Java的包，但又不完全等同，因为Java的包必须按照目录结构来放置，命名空间则不需要。

        装配件是.Net应用程序执行的最小单位，编译出来的.dll、.exe都是装配件。

        装配件和命名空间的关系不是一一对应，也不互相包含，一个装配件里面可以有多个命名空间，一个命名空间也可以在多个装配件中存在，这样说可能有点模糊，举个例子：

装配件A：

namespace   N1

{

      public   class   AC1   {…}

      public   class   AC2   {…}

}

namespace   N2

{

      public   class   AC3   {…}

      public   class   AC4{…}

}

装配件B：

namespace   N1

{

      public   class   BC1   {…}

      public   class   BC2   {…}

}

namespace   N2

{

      public   class   BC3   {…}

      public   class   BC4{…}

}

        这两个装配件中都有N1和N2两个命名空间，而且各声明了两个类，这样是完全可以的，然后我们在一个应用程序中引用装配件A，那么在这个应用程序中，我们能看到N1下面的类为AC1和AC2，N2下面的类为AC3和AC4。

        接着我们去掉对A的引用，加上对B的引用，那么我们在这个应用程序下能看到的N1下面的类变成了BC1和BC2，N2下面也一样。

        如果我们同时引用这两个装配件，那么N1下面我们就能看到四个类：AC1、AC2、BC1和BC2。

        到这里，我们可以清楚一个概念了，命名空间只是说明一个类型是那个族的，比如有人是汉族、有人是回族；而装配件表明一个类型住在哪里，比如有人住在北京、有人住在上海；那么北京有汉族人，也有回族人，上海有汉族人，也有回族人，这是不矛盾的。

        上面我们说了，装配件是一个类型居住的地方，那么在一个程序中要使用一个类，就必须告诉编译器这个类住在哪儿，编译器才能找到它，也就是说必须引用该装配件。

        那么如果在编写程序的时候，也许不确定这个类在哪里，仅仅只是知道它的名称，就不能使用了吗？答案是可以，这就是反射了，就是在程序运行的时候提供该类型的地址，而去找到它。

来个小例子吧：

public static void test1()         {
    // Loads an assembly using its file name.             Assembly a = Assembly.LoadFrom(@"F:\Documents and Settings\v-yahuan\Desktop\ttt\TestRun0501\WinApp\bin\Debug\WinApp.exe"); // Gets the type names from the assembly.             Type[] types2 = a.GetTypes(); foreach (Type t in types2)             {
                    Console.WriteLine(t.FullName); foreach (MemberInfo m in t.GetMethods())                 {
                        Console.WriteLine("methods " + m.Name);                 }             }             Console.WriteLine();         }

　　如何根据类型来动态创建对象

        System.Activator提供了方法来根据类型动态创建对象，比如创建一个DataTable：

Type   t   =   Type.GetType("System.Data.DataTable,System.Data,Version=1.0.3300.0,   Culture=neutral,   PublicKeyToken=b77a5c561934e089");DataTable   table   =   (DataTable)Activator.CreateInstance(t);

　　

namespace   TestSpace   {
    public   class   TestClass       {
    private   string   _value; public   TestClass(string   value)        {
           _value=value;        }   } } … Type   t   =   Type.GetType(“TestSpace.TestClass”); Object[]   constructParms   =   new   object[]   {“hello”};   //构造器参数 TestClass   obj   =   (TestClass)Activator.CreateInstance(t,constructParms); … 把参数按照顺序放入一个Object数组中即可

　　如何获取方法以及动态调用方法：

namespace   TestSpace {
    public   class   TestClass   {
    private   string   _value; public   TestClass()   {
              } public   TestClass(string   value)   {
                    _value   =   value;           } public   string   GetValue(   string   prefix   )   {
    if(   _value==null   ) return   "NULL"; else return   prefix+"   :   "+_value;             } public   string   Value   {
    set   {
    _value=value; } get   {
    if(   _value==null   ) return   "NULL"; else return   _value; }             }       } }

　　  上面是一个简单的类，包含一个有参数的构造器，一个GetValue的方法，一个Value属性，我们可以通过方法的名称来得到方法并且调用之，如：

//获取类型信息 Type   t   =   Type.GetType("TestSpace.TestClass"); //构造器的参数 object[]   constuctParms   =   new   object[]{
    "timmy"}; //根据类型创建对象 object   dObj   =   Activator.CreateInstance(t,constuctParms); //获取方法的信息 MethodInfo   method   =   t.GetMethod("GetValue"); //调用方法的一些标志位，这里的含义是Public并且是实例方法，这也是默认的值 BindingFlags   flag   =   BindingFlags.Public   |   BindingFlags.Instance; //GetValue方法的参数 object[]   parameters   =   new   object[]{
    "Hello"}; //调用方法，用一个object接收返回值 object   returnValue   =   method.Invoke(dObj,flag,Type.DefaultBinder,parameters,null);//反射不仅仅是获取信息，还可以调用类中的方法。

//不妨试试，在以后某个类中要想调用某个类的函数、属性时就通过反射来实现下。

　　动态创建委托

        委托是C#中实现事件的基础，有时候不可避免的要动态的创建委托，实际上委托也是一种类型：System.Delegate，所有的委托都是从这个类派生的

System.Delegate提供了一些静态方法来动态创建一个委托，比如一个委托： namespace   TestSpace   {
    delegate   string   TestDelegate(string   value); public   class   TestClass   {
    public   TestClass()   {
                      } public   void   GetValue(string   value)   {
    return   value;                   }         } }

　　

使用示例： TestClass   obj   =   new   TestClass(); //获取类型，实际上这里也可以直接用typeof来获取类型 Type   t   =   Type.GetType(“TestSpace.TestClass”); //创建代理，传入类型、创建代理的对象以及方法名称 TestDelegate   method   =   (TestDelegate)Delegate.CreateDelegate(t,obj,”GetValue”); String   returnValue   =   method(“hello”);

　　

再来个完整的例子吧：

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SKY.ReflectDemo { public class ReflectTest : IPerson      { private string _name; private int _age; public string Name                  { get { return this._name; } set { this._name = value; }                   } public int Age                 { get { return this._age; } set { this._age = value; }                 } public ReflectTest(string name, int age) {
    this._name = name; this._age = age;       } public string WelcomeInfo(string name) {
    return "welcome come here " + name;  } public static string WriteStaticInfo(string name) { return "welcome come here static" + name; } public static string WriteStaticNoParam() {
    return "Static and No parma"; } public void Show(string info) {
     Console.WriteLine(info);  } public ReflectTest() { } public string WriteNoPara() { return "你使用的是无参的方法"; } private string WritePrivate() {
    return "私有类型的方法";  } #region IPerson 成员 public int Add() {
    return Age; } #endregion } public interface IPerson {
    /// 
 /// 添加对象 /// 
 /// 
      int Add(); } }

　　

　然后再创建一个客户端程序：例如clientTestDemo,添加刚刚新建的程序集引用，引用命名空间using System.Reflection

 class Program {

delegate string TestDelegate(string name); static void Main(string[] args) { //*********************引导程序集************************// //Assembly ass =Assembly.LoadFrom(("SKY.ReflectDemo.dll")); //Assembly ass=Assembly.GetAssembly(typeof(SKY.ReflectDemo.ReflectTest); Assembly ass = Assembly.Load("SKY.ReflectDemo");//功能同上   载入程序集 Console.Write(ass.FullName+"\n"); //*********************显示该dll下所有的类***************// foreach (Type type in ass.GetTypes()) { Console.Write(type.Name+"\n"); } //*********************显示该dll下指定类**************// Type itype = ass.GetType("SKY.ReflectDemo.ReflectTest");  读取程序集中的类 Console.Write(itype.Name); Type itype1 = typeof(SKY.ReflectDemo.ReflectTest); //********************所有模块***********************// foreach (Module temp in ass.GetModules()) {
    Console.WriteLine(temp.Assembly.FullName); } //********************创建该类的实例,后面的param为有参构造函数的参数******************// object[] param = { "test", 30 };//构造函数参数     带参数的构造函数 SKY.ReflectDemo.ReflectTest temp1 = (SKY.ReflectDemo.ReflectTest)Activator.CreateInstance(itype1, param); 实例 // SKY.ReflectDemo.ReflectTest temp1 = (SKY.ReflectDemo.ReflectTest)ass.CreateInstance("SKY.ReflectDemo.ReflectTest"); Console.WriteLine(temp1.WriteNoPara()); //******************************显示所有的共有方法************************************// MethodInfo[] methods = itype.GetMethods();   遍历读取所有的方法名字 Console.WriteLine("------------------------显示所有的共有方法-------------------------"); foreach (MethodInfo temp in methods) { Console.WriteLine(temp.Name); }  输出方法名字 //******************************显示特定方法************************************// Console.WriteLine("------------------------显示特定方法------------------------------"); MethodInfo method1 = itype.GetMethod("WriteStaticInfo"); //带参的静态方法   读取特定名字的方法 Console.WriteLine(method1.Name); object[] param1 = { "使用的是静态方法" }; string s1 = (string)method1.Invoke(null, param1);   使用带有参数的方法（不用实例直接使用方法） Console.WriteLine("执行后:"+s1+"\n"); MethodInfo method2 = itype.GetMethod("WriteStaticNoParam");//无参静态方法 Console.WriteLine(method2.Name); string s2 = method2.Invoke(null, null) as string; 使用无参数的方法（不用实例直接使用方法） Console.WriteLine("执行后:" + s2 + "\n"); MethodInfo method3 = itype.GetMethod("WelcomeInfo");//带参的非静态方法 Console.WriteLine(method3.Name); object[] param2 = { "使用的是带有参数的非静态方法" }; string s3 = (string)method3.Invoke(temp1, param2); 使用带参数的静态方法 Console.WriteLine("执行后:" + s3 + "\n"); MethodInfo method4 = itype.GetMethod("WriteNoPara");//无参非静态方法  Console.WriteLine(method4.Name); string s4 = method4.Invoke(temp1, null) as string;  使用无参数的静态方法 temp1实例 Console.WriteLine("执行后:" + s4 + "\n"); MethodInfo method5 = itype.GetMethod("WritePrivate", BindingFlags.NonPublic | BindingFlags.Instance);//无参私有非静态方法 Console.WriteLine(method5.Name); string s5 = method5.Invoke(temp1, null) as string; Console.WriteLine("执行后:" + s5 + "\n"); MethodInfo method6 = itype.GetMethod("Show");//返回类型为void的方法 Console.WriteLine(method6.Name); object[]param3={
    "returnType is void"}; string s6 = method6.Invoke(temp1, param3) as string; Console.WriteLine(s6); //***********************************显示所有属性*********************************88// Console.WriteLine("------------------------显示所有属性------------------------------"); PropertyInfo[] pros = itype.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); foreach (PropertyInfo temp in pros) { Console.WriteLine(temp.Name); } //***********************************显示特定属性*********************************88// Console.WriteLine("------------------------显示特定属性------------------------------"); PropertyInfo proName = itype.GetProperty("Name"); proName.SetValue(temp1, "testName",null); Console.WriteLine(proName.GetValue(temp1, null)); //***********************************显示构造函数*********************************88// Console.WriteLine("------------------------显示构造函数------------------------------"); ConstructorInfo[] cons = itype.GetConstructors(); foreach (ConstructorInfo t in cons) { Console.WriteLine(t.ToString()); } //***********************************显示特定构造函数形式*********************************88// Console.WriteLine("------------------------显示特定构造函数形式------------------------------"); ConstructorInfo con1= itype.GetConstructor(new Type[] { typeof(string), typeof(int) }); Console.WriteLine(con1); ConstructorInfo con2 = itype.GetConstructor(new Type[] { }); Console.WriteLine(con2); //**************************************委托的使用*********************************************// Console.WriteLine("------------------------委托的使用------------------------------"); TestDelegate td = (TestDelegate)Delegate.CreateDelegate(typeof(TestDelegate), temp1, "WelcomeInfo");//非静态方法 Console.WriteLine(td("使用的是带有参数的非静态方法")); TestDelegate td2 = Delegate.CreateDelegate(typeof(TestDelegate), method1) as TestDelegate;//静态方法 Console.WriteLine(td2("使用静态方法")); // TestDelegate td1 = new TestDelegate(SKY.ReflectDemo.ReflectTest.WriteStaticInfo); // Console.WriteLine(td1("使用的是带有参数的非静态方法222")); 同上

　　也可以动态的读取配置文件来初始化类实例

Assembly a = Assembly.Load("SKY.ReflectDemo");

String carString = System.Configuration.ConfigurationManager.AppSettings["car"]; Type t = a.GetType(carString); RefluctTest car2 = (RefluctTest)Activator.CreateInstance(t);

　　car的配置文件中数据就是 类名SKY.ReflectDemo.ReflectTest

配置文件的内容：