C# 反射机制

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。

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

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

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

3、运行期得到类型信息有什么用

有人也许疑问，既然在开发时就能够写好代码，干嘛还放到运行期去做，不光繁琐，而且效率也受影响。这就是个见仁见智的问题了，就跟早绑定和晚绑定一样，应用到不同的场合。有的人反对晚绑定，理由是损耗效率，但是很多人在享受虚函数带来的好处的时侯还没有意识到他已经用上了晚绑定。这个问题说开去，不是三言两语能讲清楚的，所以就点到为止了。我的看法是，晚绑定能够带来很多设计上的便利，合适的使用能够大大提高程序的复用性和灵活性，但是任何东西都有两面性，使用的时侯，需要再三衡量。接着说，运行期得到类型信息到底有什么用呢？还是举个例子来说明，很多软件开发者喜欢在自己的软件中留下一些接口，其他人可以编写一些插件来扩充软件的功能，比如我有一个媒体播放器，我希望以后可以很方便的扩展识别的格式，那么我声明一个接口：

public  interface  IMediaFormat
{
        string  Extension  {get;}
        Decoder  GetDecoder();
}

　　这个接口中包含一个Extension属性，这个属性返回支持的扩展名，另一个方法返回一个解码器的对象（这里我假设了一个Decoder的类，这个类提供把文件流解码的功能，扩展插件可以派生之），通过解码器对象我就可以解释文件流。那么我规定所有的解码插件都必须派生一个解码器，并且实现这个接口，在GetDecoder方法中返回解码器对象，并且将其类型的名称配置到我的配置文件里面。这样的话，我就不需要在开发播放器的时侯知道将来扩展的格式的类型，只需要从配置文件中获取现在所有解码器的类型名称，而动态的创建媒体格式的对象，将其转换为IMediaFormat接口来使用。这就是一个反射的典型应用。

4、如何使用反射获取类型

首先我们来看如何获得类型信息。

获得类型信息有两种方法，一种是得到实例对象.

这个时侯我仅仅是得到这个实例对象，得到的方式也许是一个object的引用，也许是一个接口的引用，但是我并不知道它的确切类型，我需要了解，那么就可以通过调用System.Object上声明的方法GetType来获取实例对象的类型对象，比如在某个方法内，我需要判断传递进来的参数是否实现了某个接口，如果实现了，则调用该接口的一个方法：

public  void  Process(  object  processObj  )
{
        Type  t  =  processsObj.GetType();
        if(  t.GetInterface(“ITest”)  !=null  )
            ......
}

　　另外一种获取类型的方法是通过Type.GetType以及Assembly.GetType方法，如：

  Type  t  =  Type.GetType(“System.String”);

　　需要注意的是，前面我们讲到了命名空间和装配件的关系，要查找一个类，必须指定它所在的装配件，或者在已经获得的Assembly实例上面调用GetType。本装配件中类型可以只写类型名称，另一个例外是mscorlib.dll，这个装配件中声明的类型也可以省略装配件名称（.Net装配件编译的时候，默认都引用了mscorlib.dll，除非在编译的时候明确指定不引用它），比如：

System.String是在mscorlib.dll中声明的，上面的Type t = Type.GetType(“System.String”)是正确的

System.Data.DataTable是在System.Data.dll中声明的，那么： Type.GetType(“System.Data.DataTable”)就只能得到空引用。

必须：

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

　　这样才可以，大家可以看下面这个帖子，qqchen的回答很精彩

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

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数组中即可

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

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

　　属性与方法的调用大同小异，大家也可以参考MSDN

7、动态创建委托

委托是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”);

作者：泥塘·物语
出处：泥塘·物语
本站博客文章已停止更新，请移步泥塘·物语