C#之玩转反射

最新推荐文章于 2021-04-28 12:10:10 发布

转载最新推荐文章于 2021-04-28 12:10:10 发布 · 499 阅读

编程语言专栏收录该内容

50 篇文章

订阅专栏

coffeecato写在前面：

另一篇文章详解C#中的反射，对于反射的类比非常形象：

两个现实中的例子：
1、B超：大家体检的时候大概都做过B超吧，B超可以透过肚皮探测到你内脏的生理情况。这是如何做到的呢？B超是B型超声波，它可以透过肚皮通过向你体内发射B型超声波，当超声波遇到内脏壁的时候就会产生一定的“回音”反射，然后把“回音”进行处理就可以显示出内脏的情况了（我不是医生也不是声学专家，不知说得是否准确^_^）。
2、地球内部结构：地球的内部结构大体可以分为三层：地壳、地幔和地核。地壳是固体，地核是液体，地幔则是半液半固的结构（中学地理的内容，大家还记得吧？）。如何在地球表面不用深入地球内部就知道其内部的构造呢？对，向地球发射“地震波”，“地震波”分两种一种是“横波”，另一种是“纵波”。“横波”只能穿透固体，而“纵波”既可穿透固体又可以穿透液体。通过在地面对纵波和横波的反回情况，我们就可以大体断定地球内部的构造了。

大家注意到这两个例子的共同特点，就是从一个对象的外部去了解对象内部的构造，而且都是利用了波的反射功能。在.NET中的反射也可以实现从对象的外部来了解对象（或程序集）内部结构的功能，哪怕你不知道这个对象（或程序集）是个什么东西，另外.NET中的反射还可以运态创建出对象并执行它其中的方法。

反射是.NET中的重要机制，通过反射，可以在运行时获得程序或程序集中每一个类型（包括类、结构、委托、接口和枚举等）的成员和成员的信息。有了反射，即可对每一个类型了如指掌。另外我还可以直接创建对象，即使这个对象的类型在编译时还不知道。

反射的用途：
    （1）使用Assembly定义和加载程序集，加载在程序集清单中列出模块，以及从此程序集中查找类型并创建该类型的实例。
    （2）使用Module了解包含模块的程序集以及模块中的类等，还可以获取在模块上定义的所有全局方法或其他特定的非全局方法。
    （3）使用ConstructorInfo了解构造函数的名称、参数、访问修饰符（如pulic 或private）和实现详细信息（如abstract或virtual）等。
    （4）使用MethodInfo了解方法的名称、返回类型、参数、访问修饰符（如pulic 或private）和实现详细信息（如abstract或virtual）等。
    （5）使用FiedInfo了解字段的名称、访问修饰符（如public或private）和实现详细信息（如static）等，并获取或设置字段值。
    （6）使用EventInfo了解事件的名称、事件处理程序数据类型、自定义属性、声明类型和反射类型等，添加或移除事件处理程序。
    （7）使用PropertyInfo了解属性的名称、数据类型、声明类型、反射类型和只读或可写状态等，获取或设置属性值。
    （8）使用ParameterInfo了解参数的名称、数据类型、是输入参数还是输出参数，以及参数在方法签名中的位置等。

本文转自： C#之玩转反射

前言

之所以要写这篇关于C#反射的随笔，起因有两个:

第一个是自己开发的网站需要用到

其次就是没看到这方面比较好的文章。

所以下定决心自己写一篇，废话不多说开始进入正题。

前期准备

在VS2012中新建一个控制台应用程序（我的命名是ReflectionStudy），这个项目是基于.net 4.0。接着我们打开Program.cs文件，按照如下在Program中写一个我们自己的类：

 1         public class RefClass
 2         {
 3             private int _test3;
 4             private int _test1 { get; set; }
 5             protected int Test2 { get; set; }
 6             public int Test3 { get; set; }
 7 
 8             public void Show()
 9             {
10 
11             }
12         }

窥视内部

常言道知彼知己百战不殆，所以我们第一步也是关键的一步就是要窥视RefClass类的结构（这里我们假设对RefClass并不理解）。

首先我们先要纵览全局才能继续深入，所以我们先在Main中写入如下代码：

 1         static void Main(string[] args)
 2         {
 3             Type t = typeof(RefClass);
 4             MemberInfo[] minfos = t.GetMembers();
 5             foreach (MemberInfo minfo in minfos)
 6             {
 7                 Console.WriteLine(minfo.Name);
 8             }
 9             Console.ReadKey();
10         }

在这里我们获取这个类的类型，然后获取了其中的公共成员（可能很多人都会认为GetMembers是获取全部，但其实只是获取公开的所有成员。）然后我们通过foreach将所有的成员的名称循环输出。

然后我们可以查看控制台的输出：

在这里我们可以看到其中不仅仅输出了我们所写类中的成员，同时还输出了父类的成员（如果不理解的这里帮你们补充下基础，Object是所有类的基类。），细心的读者一定会发现这里的输出并没有包含private和protected访问权限的成员。这就应了上面的那句话：GetMembers默认返回公开的成员。

仅仅只能看到这些公开的成员对我们来说意义并不大，所以我们需要查看到那些非公有的成员。

下面我们将上面的代码改成如下所示：

 1         static void Main(string[] args)
 2         {
 3             Type t = typeof(RefClass);
 4             MemberInfo[] minfos = t.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public );
 5             foreach (MemberInfo minfo in minfos)
 6             {
 7                 Console.WriteLine(minfo.Name);
 8             }
 9             Console.ReadKey();
10         }

从中我们看到我们使用了GetMembers的重载版本，并且传入了枚举类型，分别是“包含非公开”、“包含实例成员”和“包含公开”。然后我们就可以获取到所有成员了。

最终我们将会得出下面这些成员：

到这里你可能会认为我们已经检索结束了，但是你有没有发现属性很多，而且还包含了大量的父类中的属性，假设我们只关注该类中的成员，并不关注父类中的成员该如何做呢？

其实我们只需要加上一个枚举类型（BindingFlags.DeclaredOnly）：

1 MemberInfo[] minfos = t.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly );

然后我们再查看结果：

此时就只包含该类中的成员了。

下面我们在RefClass类中添加两个静态方法，如下所示：

 1        public class RefClass
 2         {
 3             private int _test3;
 4             private int _test1 { get; set; }
 5             protected int Test2 { get; set; }
 6             public int Test3 { get; set; }
 7 
 8             private static void Show2()
 9             {
10             }
11 
12             public static void Show3()
13             {
14             }
15 
16             public void Show()
17             {
18 
19             }
20         }

然后我们继续查看，可以发现最终的结果并没有输出这些静态成员。这个时候我们只需要在GetMembers中加上一个枚举：BindingFlags.Static即可。

这里我们仅仅输出了所有的成员，但是却没有区分出是方法还是属性所以我们在Main中添加一个方法：

 1         static void Main(string[] args)
 2         {
 3             Type t = typeof(RefClass);
 4             Func<MemberTypes, String> getType = (x) =>
 5             {
 6                 switch (x)
 7                 {
 8                     case MemberTypes.Field:
 9                         {
10                             return "字段";
11                         }
12                     case MemberTypes.Method:
13                         {
14                             return "方法";
15                         }
16                     case MemberTypes.Property:
17                         {
18                             return "属性";
19                         }
20                     default:
21                         {
22                             return "未知";
23                         }
24                 }
25             };
26             MemberInfo[] minfos = t.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static );
27             foreach (MemberInfo minfo in minfos)
28             {
29                 Console.WriteLine(minfo.Name + ";类型:" + getType(minfo.MemberType));
30             }
31             Console.ReadKey();
32         }

这里我用了一个局部方法来根据类型输出对应的文本，因为篇幅的原因我就只判断了几个基本的类型。

最终输出的结果如下：

到此为止我们已经能够窥视整个结构。

深入窥视字段

通过上面的内容我们仅仅纵览了全局，下面我们将要继续深入，首先我们先拿字段下手。

这里我们不在使用GetMembers而需要使用GetFields（当然跟GetMembers一样如果不传入指定的枚举只返回公开的字段），代码如下所示：

 1         static void Main(string[] args)
 2         {
 3             Type t = typeof(RefClass);
 4             FieldInfo[] finfos = t.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
 5             foreach (FieldInfo finfo in finfos)
 6             {
 7                 Console.WriteLine("字段名称：{0}  字段类型:{1} ", finfo.Name, finfo.FieldType.ToString());
 8             }
 9             Console.ReadKey();
10         }

最终的输出结果如下所示：

一直到这里大家都会认为我们仅仅只是分析，感觉没有什么实质的东西，下面就来点实质的东西，你可以看到_test3、_test1和Test2是私有和保护类型，

是不可以获取到它们的值的，但是我们通过反射却可以，具体的代码如下所示：

 1         static void Main(string[] args)
 2         {
 3             Type t = typeof(RefClass);
 4             RefClass rc = new RefClass();
 5             rc.Test3 = 3;
 6             FieldInfo[] finfos = t.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
 7             foreach (FieldInfo finfo in finfos)
 8             {
 9                 Console.WriteLine("字段名称：{0}  字段类型:{1} rc中的值为:{2}", finfo.Name, finfo.FieldType.ToString(), finfo.GetValue(rc));
10             }
11             Console.ReadKey();
12         }

可以看到我实例化了这个类，并且设置了Test3为3，下面我通过finfo.GetValue输出了这个值，结果如下图：

现在是不是感觉有点酷了？这还没完呢，我们光获取不算什么，下面我们还要修改它的值：

 1         static void Main(string[] args)
 2         {
 3             Type t = typeof(RefClass);
 4             RefClass rc = new RefClass();
 5             rc.Test3 = 3;
 6             FieldInfo[] finfos = t.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
 7             foreach (FieldInfo finfo in finfos)
 8             {
 9                 finfo.SetValue(rc, 100);
10                 Console.WriteLine("字段名称：{0}  字段类型:{1} rc中的值为:{2}", finfo.Name, finfo.FieldType.ToString(), finfo.GetValue(rc));
11             }
12             Console.ReadKey();
13         }

这里我只是在foreach中增加了一条语句finfo.SetValue(rc,100)，下面我们继续看最终输出的结果：

是不是现在感觉可以为所欲为了？但是还没有完。

深入窥视属性

因为属性存在get和set，并且两者都是方法，所以比较棘手。我们需要通过属性对象获取get和set方法，在通过调用他们才达到修改这个属性的值。

比如下面的代码：

 1         static void Main(string[] args)
 2         {
 3             Type t = typeof(RefClass);
 4             RefClass rc = new RefClass();
 5             rc.Test3 = 3;
 6             PropertyInfo[] finfos = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
 7             foreach (PropertyInfo finfo in finfos)
 8             {
 9                 MethodInfo getinfo = finfo.GetGetMethod(true);
10                 Console.WriteLine("get方法的名称{0}  返回值类型:{1}  参数数量:{2}  MSIL代码长度:{3} 局部变量数量:{4}", getinfo.Name, getinfo.ReturnType.ToString(),
11                     getinfo.GetParameters().Count(),
12                     getinfo.GetMethodBody().GetILAsByteArray().Length, 
13                     getinfo.GetMethodBody().LocalVariables.Count);
14 
15                 MethodInfo setinfo = finfo.GetSetMethod(true);
16                 Console.WriteLine("get方法的名称{0}  返回值类型:{1}  参数数量:{2}  MSIL代码长度:{3} 局部变量数量:{4}", setinfo.Name, setinfo.ReturnType.ToString(),
17                     setinfo.GetParameters().Count(),
18                     setinfo.GetMethodBody().GetILAsByteArray().Length,
19                     setinfo.GetMethodBody().LocalVariables.Count);
20 
21                 setinfo.Invoke(rc, new object[] { 123 });
22                 object obj = getinfo.Invoke(rc, null);
23                 Console.WriteLine("方法名:{0}  内部值:{1}", finfo.Name, obj);
24             }
25             Console.ReadKey();
26         }

这里我们循环每个属性，通过GetGetMethod获取get方法（调用该方法时如果传入true则无法获取非公开的get方法set也是一样），接着我们输出了该方法的返回类型和参数数量和MSIL代码长度以及局部变量的数量，

当然你如果有兴趣可以继续分析输入参数以及局部变量等，这里由于篇幅的缘故就不能介绍太多了。最后我们调用了set方法将值改变，然后再通过调用get方法获取这个属性的值。

最终的结果如下所示:

深入窥视方法

首先我们需要将RefClass修改成如下所示:

 1         public class RefClass
 2         {
 3             private int _test3;
 4             private int _test1 { get; set; }
 5             protected int Test2 { get; set; }
 6             public int Test3 { get; set; }
 7 
 8             private static void Show2()
 9             {
10 
11             }
12 
13             public static string Show3(string s)
14             {
15                 int b;
16                 int c;
17                 return s;
18             }
19 
20             public string Show(string s)
21             {
22                 string a;
23                 return s;
24             }
25         }

主要是在方法中增加局部变量并且加上返回值，避免最后输出的时候没有值。其实这里的方法跟属性部分类似，但是为了能够完整的描述所有，所以笔者依然会讲解一遍。

下面我们直接上代码：

 1         static void Main(string[] args)
 2         {
 3             Type t = typeof(RefClass);
 4             RefClass rc = new RefClass();
 5             rc.Test3 = 3;
 6             MethodInfo[] finfos = t.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static );
 7             foreach (MethodInfo finfo in finfos)
 8             {
 9                 if (finfo.GetParameters().Count() > 0 && finfo.GetParameters()[0].ParameterType == typeof(string) )
10                 {
11                     object obj = finfo.Invoke(rc, new[] { "123" });
12                     MethodBody mbody = finfo.GetMethodBody();
13                     Console.WriteLine("拥有参数的方法名:{0}  返回值类型:{1}  参数1类型:{2}  参数1名称:{3}  方法调用后返回的值:{4}",
14                         finfo.Name,
15                         finfo.ReturnType.ToString(),
16                         finfo.GetParameters()[0].ParameterType.ToString(),
17                         finfo.GetParameters()[0].Name,
18                         obj.ToString());
19                 }
20                 else
21                 {
22                     MethodBody mbody = finfo.GetMethodBody();
23                     Console.WriteLine("没有参数的方法名:{0}  返回值类型:{1}",
24                         finfo.Name,
25                         finfo.ReturnType.ToString());
26                 }
27             }
28             Console.ReadKey();
29         }