浅谈.NET中的反射

一、概述 

1、通过反射可以提供类型信息，从而使得我们开发人员在运行时能够利用这些信息构造和使用对象

2、反射机制允许程序在执行过程中动态地添加各种功能

二、运行时类型标识

1、运行时类型标志（rtti），可以在程序执行期间判断对象类型。例如使用他能够确切的知道基类引用指向了什么类型对象。

2、运行时类型标识，能预先测试某个强制类型转换操作，能否成功，从而避免无效的强制类型转换异常。

3、在c#中有三个支持rtti的关键字：is、as、typeof。下面一次介绍他们

is运算符：

通过is运算符，能够判断对象类型是否为特定类型，如果两种类型时相同类型，或者两者之间存在引用，装箱拆箱转换，则表明两种类型时兼容的。代码如下：

 1         static void main()
 2         {
 3             a a = new a();
 4             b b = new b();
 5             if (a is a)
 6             {
 7                 console.writeline("a is an a");
 8             }
 9 
10             if (b is a)
11             {
12                 console.writeline("b is an a because it is derived from");
13             }
14 
15             if (a is b)
16             {
17                 console.writeline("this won't display,because a not derived from b");
18             }
19 
20             if (a is object)
21             {
22                 console.writeline("a is an object");
23             }
24             console.readkey();
25         }

结果：

 

 as运算符：

在运行期间执行类型转换，并且能够是的类型转换失败不抛出异常，而返回一个null值，其实as也可以看作一个is运算符的简化备选方式，如下：

 

 1         static void main()
 2         {
 3             a a = new a();
 4             b b = new b();
 5             if (a is b)
 6             {
 7                 b = (b) a;//由于a变量不是b类型，因此这里将a变量转换为b类型时无效的
 8             }
 9             else
10             {
11                 b = null;
12             }
13 
14             if (b==null)
15             {
16                 console.writeline("the cast in b=(b)a is not allowed");
17             }
18             //上面使用as运算符，能够把两部分合二为一
19             b = a as b;//as运算符先检查将之转换类型的有效性，如果有效，则执行强类型转换过程，这些都在这一句话完成
20             if (b==null)
21             {
22                 console.writeline("the cast in b=(b)a is not allowed");
23             }
24             console.readkey();
25         }

结果：

 

 typeof运算符：

as、is 能够测试两种类型的兼容性，但大多数情况下，还需要获得某个类型的具体信息。这就用到了typeof，他可以返回与具体类型相关的system.type对象，通过system.type对象可以去定此类型的特征。一旦获得给定类型的type对象，就可以通过使用对象定义的各自属性、字段、方法来获取类型的具体信息。type类包含了很多成元，在接下来的反射中再详细讨论。下面简单的演示type对象，调用它的三个属性。

 

 1         static void main()
 2         {
 3             type t = typeof(stringbuilder);
 4             console.writeline(t.fullname);//fullname属性返回类型的全称
 5             if (t.isclass)
 6             {
 7                 console.writeline("is a class");
 8             }
 9 
10             if (t.issealed)
11             {
12                 console.writeline("is sealed");
13             }
14             console.readkey();
15         }

结果：

 

 

三、反射的核心类型：system.type类

1、许多支持反射的类型都位于system.reflection命名空间中，他们是.net reflection api的一部分，所以再使用的反射的程序中一般都是要使用system.reflection的命名空间。

2、system.type类包装了类型，因此是整个反射子系统的核心，这个类中包含了很多属性和方法，使用这些属性和方法可以再运行时得到类型的信息。

3、type类派生于system.reflection.memberinfo抽象类

memberinfo类中的只读属性
属性	描述
type declaringtype	获取声明该成员的类或接口的类型
membertypes  membertype	获取成员的类型，这个值用于指示该成员是字段、方法、属性、事件、或构造函数
int metadatatoken	获取与特定元数据相关的值
module module	获取一个代表反射类型所在模块（可执行文件）的module对象
string  name	成员的名称
type  reflectedtype	反射的对象类型

请注意：

1、membertype属性的返回类型为membertypes，这是一个枚举，它定义了用于表示不同成元的信息值，这些包括：membertypes.constructor、memebertypes.method、membertypes.event、membertypes.property。因此可以通过检查membertype属性来确定成元的类型，例如在menbertype属性的值为membertypes.method时，该成员为方法

2、memberinfo类还包含两个与特性相关的抽象方法：

（1）getcustomattributes()：获得与主调对象相关的自定义特性列表。

（2）isdefined()：确定是否为主调对象定义了相应的特性。

（3）getcustomeattributesdata()：返回有关自定义特性的信息（特性稍后便会提到）

当然除了memberinfo类定义的方法和属性外，type类自己也添加了许多属性和方法：如下表（只列出一些常用的，太多二零，自己可以转定义type类看一下）

type类定义的方法
方法	功能
constructorinfo[]  getconstructors()	获取指定类型的构造函数列表
eventinfo[]   getevents();	获取指定类型的时间列
fieldinfo[]   getfields();	获取指定类型的字段列
type[]   getgenericarguments();	获取与已构造的泛型类型绑定的类型参数列表，如果指定类型的泛型类型定义，则获得类型形参。对于正早构造的类型，该列表就可能同时包含类型实参和类型形参
memberinfo[]   getmembers();	获取指定类型的成员列表
methodinfo[]   getmethods();	获取指定类型的方法列表
propertyinfo[]   getproperties();	获取指定类型的属性列表

下面列出type类型定义的常用只读属性

type类定义的属性
属性	功能
assembly   assembly	获取指定类型的程序集
typeattributes   attributes	获取制定类型的特性
type   basetype	获取指定类型的直接基类型
string  fullname	获取指定类型的全名
bool   isabstract	如果指定类型是抽象类型，返回true
bool   isclass	如果指定类型是类，返回true
string   namespace	获取指定类型的命名空间

四、使用反射

上面将的这些，都是为了使用反射做铺垫的。

通过使用type类定义的方法和属性，我们能够在运行时获得类型的各种具体信息。这是一个非常强大的功能，我们一旦得到类型信息，就可以调用其构造函数、方法、属性，可见，反射是允许使用编译时不可用的代码的。

由于feflection api非常多，这里不可能完整的介绍他们（这里如果完整的介绍，据说要一本书，厚书）。但是reflection api是按照一定逻辑设计的，因此，只要知道部分接口的使用方法，就可以举一反三的使用剩余的接口。

这里我列出四种关键的反射技术：

1、获取方法的信息

2、调用方法

3、构造对象

4、从程序集中加载类型

五、获取方法的相关信息

一旦有了type对象就可以使用getmethodinfo()方法获取此类型支持的所有方法列表。该方法返回一个methodinfo对象数组，methodinfo对象表述了主调类型所支持的方法，它位于system.reflection命名空间中。methodinfo类派生于methodbase抽象类，而methodbase类继承了memberinfo类，因此，我们能够使用这三各类定义的属性和方法。例如，使用name属性的到方法名，这里有两个重要的成员：

1、returntype属性：为type类型的对象，能够提供方法的返回类型信息。

2、getparameters()方法：返回参数列表，参数信息以数组的形式保存在patameterinfo对象中。patameterinfo类定义了大量表述参数信息的属性和方法，这里也累出两个常用的属性：name（包含参数名称信息的字符串），parametertype（参数类型的信息）。

下面代码我将使用反射获得类中的所支持的方法，还有方法的信息：

 

 1     class program
 2     {
 3         static void main()
 4         {
 5             //获取描述myclass类型的type对象
 6             type t = typeof(myclass);
 7             console.writeline($"analyzing methods in {t.name}");
 8             //methodinfo对象在system.reflection命名空间下
 9             methodinfo[] mi = t.getmethods();
10             foreach (var methodinfo in mi)
11             {
12                 //返回方法的返回类型
13                 console.write(methodinfo.returntype.name);
14                 //返回方法的名称
15                 console.write($" {methodinfo.name} (");
16                 //获取方法阐述列表并保存在parameterinfo对象组中
17                 parameterinfo[] pi = methodinfo.getparameters();
18                 for (int i = 0; i < pi.length; i++)
19                 {
20                     //方法的参数类型名称
21                     console.write(pi[i].parametertype.name);
22                     //方法的参数名
23                     console.write($" {pi[i].name}");
24                     if (i+1<pi.length)
25                     {
26                         console.write(", ");
27                     }
28                 }
29 
30                 console.write(")");
31                 console.write("\r\n");
32                 console.writeline("--------------------------");
33             }
34             console.readkey();
35         }
36     }
37 
38     class myclass
39     {
40         private int x;
41         private int y;
42 
43         public myclass()
44         {
45             x = 1;
46             y = 1;
47         }
48 
49         public int sum()
50         {
51             return x + y;
52         }
53 
54         public bool isbetween(int i)
55         {
56             if (x < i && i < y)
57             {
58                 return true;
59             }
60 
61             return false;
62         }
63 
64         public void set(int a, int b)
65         {
66             x = a;
67             y = b;
68         }
69 
70         public void set(double a, double b)
71         {
72             x = (int)a;
73             y = (int)b;
74         }
75 
76         public void show()
77         {
78             system.console.writeline($"x:{x},y:{y}");
79         }
80     }

输出结果：

 

 注意：这里输出的除了myclass类定义的所有方法外，也会显示object类定义的共有非静态方法。这是因为c#中的所有类型都继承于object类。另外，这些信息是在程序运行时动态获得的，并不需要知道myclass类的定义

getmethods()方法的另一种形式

这种形式可以指定各种标记，已筛选想要获取的方法，他的通用形式为：methodinfo[] getmethods(bindingflags bindingattr)

bindingflags是一个枚举，枚举值有（很多，这里只列出5个常用的吧）

（1）declareonly：仅获取指定类定义的方法，而不获取所继承的方法

（2）instance：获取实例方法

（3）nonpublic：获取非公有方法

（4）public：获取共有方法

（5）static：获取静态方法

getmethods(bindingflags bindingattr)这个方法，参数可以使用 or 把两个或更多标记连接在一起，实际上至少要有instance（或 static）与public（或 nonpublic）标记，否则将不会获取任何方法。下我们就写一个示例来演示一下。

 1     class program
 2     {
 3         static void main()
 4         {
 5             //获取描述myclass类型的type对象
 6             type t = typeof(myclass);
 7             console.writeline($"analyzing methods in {t.name}");
 8             //methodinfo对象在system.reflection命名空间下
 9             //不获取继承方法，为实例方法，·为公用的
10             methodinfo[] mi = t.getmethods(bindingflags.declaredonly|bindingflags.instance|bindingflags.public);
11             foreach (var methodinfo in mi)
12             {
13                 //返回方法的返回类型
14                 console.write(methodinfo.returntype.name);
15                 //返回方法的名称
16                 console.write($" {methodinfo.name} (");
17                 //获取方法阐述列表并保存在parameterinfo对象组中
18                 parameterinfo[] pi = methodinfo.getparameters();
19                 for (int i = 0; i < pi.length; i++)
20                 {
21                     //方法的参数类型名称
22                     console.write(pi[i].parametertype.name);
23                     //方法的参数名
24                     console.write($" {pi[i].name}");
25                     if (i+1<pi.length)
26                     {
27                         console.write(", ");
28                     }
29                 }
30 
31                 console.write(")");
32                 console.write("\r\n");
33                 console.writeline("--------------------------");
34             }
35             console.readkey();
36         }
37     }
38 
39     class myclass
40     {
41         private int x;
42         private int y;
43 
44         public myclass()
45         {
46             x = 1;
47             y = 1;
48         }
49 
50         public int sum()
51         {
52             return x + y;
53         }
54 
55         public bool isbetween(int i)
56         {
57             if (x < i && i < y)
58             {
59                 return true;
60             }
61 
62             return false;
63         }
64 
65         public void set(int a, int b)
66         {
67             x = a;
68             y = b;
69         }
70 
71         public void set(double a, double b)
72         {
73             x = (int)a;
74             y = (int)b;
75         }
76 
77         public void show()
78         {
79             system.console.writeline($"x:{x},y:{y}");
80         }
81     }

输出结果：

 

上面例子可以看出，只显示了myclass类显示定义的方法，private int sum() 也不显示了 

六、使用反射调用方法

上面我们通过反射获取到了类中的所有信息，下面我们就再使用反射调用反射获取到的方法。要调用反射获取到的方法，则需要在methodinfo实例上调用invoke()方法，invoke()的使用，在下面例子中演示说明：

下面例子是先通过反射获取到要调用的方法，然后使用invoke()方法，调用获取到的指定方法：

 

 1     class program
 2     {
 3         static void main()
 4         {
 5             //获取描述myclass类型的type对象
 6             type t = typeof(myclass);
 7             myclass reflectobj = new myclass();
 8             reflectobj.show();
 9             //不获取继承方法，为实例方法，·为公用的
10             methodinfo[] mi = t.getmethods(bindingflags.declaredonly | bindingflags.instance | bindingflags.public);
11             foreach (var methodinfo in mi)
12             {
13 
14                 //获取方法阐述列表并保存在parameterinfo对象组中
15                 parameterinfo[] pi = methodinfo.getparameters();
16                 if (methodinfo.name.equals("set", stringcomparison.ordinal) && pi[0].parametertype == typeof(int))
17                 {
18                     object[] args = new object[2];
19                     args[0] = 9;
20                     args[1] = 10;
21                     methodinfo.invoke(reflectobj,args);
22                 }
23             }
24             console.readkey();
25         }
26     }
27 
28     class myclass
29     {
30         private int x;
31         private int y;
32 
33         public myclass()
34         {
35             x = 1;
36             y = 1;
37         }
38 
39         public int sum()
40         {
41             return x + y;
42         }
43 
44         public bool isbetween(int i)
45         {
46             if (x < i && i < y)
47             {
48                 return true;
49             }
50 
51             return false;
52         }
53 
54         public void set(int a, int b)
55         {
56             x = a;
57             y = b;
58             show();
59         }
60 
61         private void set(double a, double b)
62         {
63             x = (int)a;
64             y = (int)b;
65         }
66 
67         public void show()
68         {
69             system.console.writeline($"x:{x},y:{y}");
70         }
71     }

获取type对象的构造函数

这个之前的阐述中，由于myclass类型的对象都是显示创建的，因此使用反射技术调用myclass类中的方法是没有任何优势的，还不如以普通方式调用方便简单呢，但是，如果对象是在运行时动态创建的，反射功能的优势就会显现出来。在这种情况下，要先获取一个构造函数列表，然后调用列表中的某个构造函数，创建一个该类型的实例，通过这种机制，可以在运行时实例化任意类型的对象，而不必在声明语句中指定类型。

示例代码如下：

 

 1     class program
 2     {
 3         static void main()
 4         {
 5             //获取描述myclass类型的type对象
 6             type t = typeof(myclass);
 7             int val;
 8             //使用这个方法获取构造函数列表
 9             constructorinfo[] ci = t.getconstructors();
10             int x;
11             for (x = 0; x < ci.length; x++)
12             {
13                 //获取当构造参数列表
14                 parameterinfo[] pi = ci[x].getparameters();
15                 if (pi.length == 2)
16                 {
17                     //如果当前构造函数有2个参数，则跳出循环
18                     break;
19                 }
20             }
21 
22             if (x == ci.length)
23             {
24                 return;
25             }
26             object[] consargs = new object[2];
27             consargs[0] = 10;
28             consargs[1] = 20;
29             //实例化一个这个构造函数有连个参数的类型对象，如果参数为空，则为null
30 
31             object reflectob = ci[x].invoke(consargs);
32 
33             methodinfo[] mi = t.getmethods(bindingflags.declaredonly | bindingflags.instance | bindingflags.public);
34             foreach (var methodinfo in mi)
35             {
36                 if (methodinfo.name.equals("sum", stringcomparison.ordinal))
37                 {
38                     val = (int)methodinfo.invoke(reflectob, null);
39                     console.writeline($"sum is {val}");
40                 }
41             }
42             console.readkey();
43         }
44     }
45 
46     class myclass
47     {
48         private int x;
49         private int y;
50 
51         public myclass(int i)
52         {
53             x = y + i;
54         }
55 
56         public myclass(int i, int j)
57         {
58             x = i;
59             y = j;
60         }
61 
62         public int sum()
63         {
64             return x + y;
65         }
66     }

输出结果：

 

 七、从程序集获得类型

在这之前的阐述中可以看出一个类型的所有信息都能够通过反射得到，但是myclass类型本身，我们却没有做到获取，虽然前面的阐述实例，可以动态确定myclass类的信息，但是他们都是基于以下事实：预先知道类型名称，并且在typeof与剧中使用它获得type对象。尽管这种方式可能在很多情况下都管用，但是要发挥反射的全部功能，我们还需要分析反射程序集的内容来动态确定程序的可用类型。

借助reflection api，可以加载程序集，获取它的相关信息并创建其公共可用类型的实例，通过这种机制，程序能够搜索其环境，利用潜在的功能，而无需再编译期间显示的定义他们，这是一个非常有效且令人兴奋的概念。为了说明如何获取程序集中的类型，我创建了两个文件，第一个文件定义一组类，第二个文件则反射各个类型的信息。代码效果如下：

1、这下面代码编译生成mytest2_c.exe文件

 1     class program
 2     {
 3         static void main(string[] args)
 4         {
 5             console.writeline("hello word !");
 6             console.readkey();
 7         }
 8     }
 9 
10     class myclass
11     {
12         private int x;
13         private int y;
14 
15         public myclass(int i)
16         {
17             x = y + i;
18         }
19 
20         public myclass(int i, int j)
21         {
22             x = i;
23             y = j;
24         }
25 
26         public int sum()
27         {
28             return x + y;
29         }
30     }

2、这下面的代码时获取上面生成程序集的

 1     class program
 2     {
 3         static void main()
 4         {
 5             //加载指定的程序集
 6             assembly asm = assembly.loadfrom(@"e:\自己的\mytest\mytest2_c\bin\debug\mytest2_c.exe");
 7             //获取程序集中的所有类型列表
 8             type[] alltype = asm.gettypes();
 9             foreach (var type in alltype)
10             {
11                 //打印出类型名称
12                 console.writeline(type.name);
13             }
14 
15             console.readkey();
16         }
17     }

输出结果：

 

 上面获取到了程序集中的类型，如果像操作程序集类型中的方法，则跟前面我们表述的方法一样操作即可。

好了，.net反射我们就介绍到这里啦~