.Net 中的反射(查看基本类型信息) - Part.2

末蓝、 2022-01-05 17:43 74阅读 0赞

# .Net 中的反射(查看基本类型信息) - Part.2 #

## 反射概述 和Type类 ##

### 1.反射的作用 ###

简单来说，反射提供这样几个能力：1、查看和遍历类型(及其成员)的基本信息和程序集元数据(metadata)；2、迟绑定(Late-Binding)方法和属性。3、动态创建类型实例(并可以动态调用所创建的实例的方法、字段、属性)。序章中，我们所采用的那个例子，只是反射的一个用途：查看类型成员信息。接下来的几个章节，我们将依次介绍反射所提供的其他能力。

### 2.获取Type对象实例 ###

反射的核心是Type类，这个类封装了关于对象的信息，也是进行反射的入口。当你获得了关于类型的Type对象后，就可以根据Type提供的属性和方法获取这个类型的一切信息(方法、字段、属性、事件、参数、构造函数等)。我们开始的第一步，就是获取关于类型的Type实例。获取Type对象有两种形式，一种是获取当前加载程序集中的类型(Runtime)，一种是获取没有加载的程序集的类型。

我们先考虑Runtime时的Type，一般来说有三种获取方法：

#### 2.1使用Type类提供的静态方法GetType() ####

比如我们想要获得Stream类型的Type实例，则可以这样：

Type t = Type.GetType("System.IO.Stream");  
txtOutput.Text = t.ToString();

注意到GetType方法接受字符串形式的类型名称。

#### 2.2 使用 typeof 操作符 ####

也可以使用C\# 提供的typeof 操作符来完成这一过程：

// 如果在页首写入了using System.IO; 也可以直接用 typeof(Stream);  
Type t = typeof(System.IO.Stream);

这时的使用有点像泛型，Stream就好像一个类型参数一样，传递到typeof操作符中。

#### 2.3 通过类型实例获得Type对象 ####

我们还可以通过类型的实例来获得：

String name = "Jimmy Zhang";  
Type t = name.GetType();

使用这种方法时应当注意，尽管我们是通过变量(实例)去获取Type对象，但是Type对象不包含关于这个特定对象的信息，仍是保存对象的类型(String)的信息。

### 3.Type类型 及 Reflection命名空间的组织结构 ###

到现在为止，我已经多次提过Type封装了类型的信息，那么这些类型信息都包含什么内容呢？假设我们现在有一个类型的实例，它的名字叫做 demo，我们对它的信息一无所知，并通过下面代码获取了对于它的Type实例：

// 前面某处的代码实例化了demo对象  
Type t = demo.GetType();

现在，我们期望 t 包含了关于 demo 的哪些信息呢？

#### 3.1 demo的类型的基本信息 ####

*  我们当然首先想知道 demo 是什么类型的，也就是 demo 的类型名称。
 *  我们还想知道该类型位于什么命名空间下。
 *  它的基类型是什么，以及它在.Net运行库中的映射类型。
 *  它是值类型还是引用类型。
 *  它是不是Public的。
 *  它是枚举、是类、是数组、还是接口。
 *  它是不是基础类型(int等)。
 *  等等 ...

Type 提供了下面的属性，用于获取类型的基本信息，常用的有下面一些：

<table> 
 <tbody> 
  <tr> 
   <td> <strong>属 性</strong></td> 
   <td> <strong>说 明</strong></td> 
  </tr> 
  <tr> 
   <td> Name</td> 
   <td> 获取类型名称</td> 
  </tr> 
  <tr> 
   <td> FullName</td> 
   <td> 类型全名</td> 
  </tr> 
  <tr> 
   <td> Namespace</td> 
   <td> 命名空间名称</td> 
  </tr> 
  <tr> 
   <td> BaseType</td> 
   <td> 获取对于基类的Type类型的引用</td> 
  </tr> 
  <tr> 
   <td> UnderlyingSystemType</td> 
   <td> 在.Net中映射的类型的引用</td> 
  </tr> 
  <tr> 
   <td> Attributes</td> 
   <td> 获取TypeAttributes位标记</td> 
  </tr> 
  <tr> 
   <td> IsValueType</td> 
   <td> 是否值类型</td> 
  </tr> 
  <tr> 
   <td> IsByRef</td> 
   <td> 是否由引用传递</td> 
  </tr> 
  <tr> 
   <td> IsEnum</td> 
   <td> 是否枚举</td> 
  </tr> 
  <tr> 
   <td> IsClass</td> 
   <td> 是否类</td> 
  </tr> 
  <tr> 
   <td> IsInterface</td> 
   <td> 是否接口</td> 
  </tr> 
  <tr> 
   <td> IsSealed</td> 
   <td> 是否密封类</td> 
  </tr> 
  <tr> 
   <td> IsPrimitive</td> 
   <td> 是否基类型(比如int)</td> 
  </tr> 
  <tr> 
   <td> IsAbstract</td> 
   <td> 是否抽象</td> 
  </tr> 
  <tr> 
   <td> IsPublic</td> 
   <td> 是否公开</td> 
  </tr> 
  <tr> 
   <td> IsNotPublic</td> 
   <td> 是否非公开</td> 
  </tr> 
  <tr> 
   <td> IsVisible</td> 
   <td> 是否程序集可见</td> 
  </tr> 
  <tr> 
   <td> 等等... </td> 
   <td>&nbsp; </td> 
  </tr> 
 </tbody> 
</table>

#### 3.2 demon的类型的成员信息 ####

*  我们可能还想知道它有哪些字段。
 *  有些什么属性，以及关于这些属性的信息。
 *  有哪些构造函数。
 *  有哪些方法，方法有哪些参数，有什么样的返回值。
 *  包含哪些事件。
 *  实现了哪些接口。
 *  我们还可以不加区分地获得它的所有 以上成员。

观察上面的列表，就拿第一条来说，我们想获取类型都有哪些字段，以及这些字段的信息。而字段都包含哪些信息呢？可能有字段的类型、字段的名称、字段是否public、字段是否为const、字段是否是read only 等等，那么是不是应该将字段的这些信息也封装起来呢？

实际上，.Net中提供了 FiledInfo 类型，它封装了关于字段的相关信息。对照上面的列表，类似的还有 PropertyInfo类型、ConstructorInfo类型、MethodInfo类型、EventInfo类型。而对于方法而言，对于它的参数，也会有in参数，out参数，参数类型等信息，类似的，在 System.Reflection 命名空间下，除了有上面的提到的那么多Info后缀结尾的类型，还有个ParameterInfo 类型，用于封装方法的参数信息。

最后，应该注意到 Type 类型，以及所有的Info类型均 继承自 MemberInfo 类型，MemberInfo类型提供了获取类型基础信息的能力。

在VS2005中键入Type，选中它，再按下F12跳转到Type类型的定义，纵览Type类型的成员，发现可以大致将属性和方法分成这样几组：

*  IsXXXX，比如 IsAbstract，这组bool属性用于说明类型的某个信息。(前面的表格已经列举了一些。)
 *  GetXXXX()，比如GetField()，返回FieldInfo，这组方法用于获取某个成员的信息。
 *  GetXXXXs()，比如GetFields()，返回FieldInfo\[\]，这组方法用户获取某些成员信息。
 *  还有其他的一些属性和方法，等后面遇到了再说。

由于MemberInfo是一个基类，当我们获得一个MemberInfo后，我们并不知道它是PropertyInfo(封装了属性信息的对象)还是FieldInfo(封装了属性信息的对象)，所以，有必要提供一个办法可以让我们加以判断，在Reflection 命名空间中，会遇到很多的位标记，这里先介绍第一个位标记(本文管用\[Flags\]特性标记的枚举称为 位标记)，MemberTypes，它用于标记成员类型，可能的取值如下：

\[Flags\]  
public enum MemberTypes \{  
Constructor = 1, // 该成员是一个构造函数  
Event = 2, // 该成员是一个事件  
Field = 4, // 该成员是一个字段  
Method = 8, // 该成员是一个方法  
Property = 16, // 该成员是一个属性  
TypeInfo = 32, // 该成员是一种类型  
Custom = 64, // 自定义成员类型  
NestedType = 128, // 该成员是一个嵌套类型  
All = 191, // 指定所有成员类型。  
\}

## 反射程序集 ##

在.Net中，程序集是进行部署、版本控制的基本单位，它包含了相关的模块和类型，我并不打算详细地去说明程序集及其构成，只是讲述如何通过反射获取程序集信息。

在System.Reflection命名空间下有一个Assembly类型，它代表了一个程序集，并包含了关于程序集的信息。

在程序中加载程序集时，一般有这么几个方法，我们可以使用 Assembly类型提供的静态方法LoadFrom() 和 Load()，比如：

Assembly asm = Assembly.LoadFrom("Demo.dll");

或者

Assembly asm = Assembly.Load("Demo");

当使用LoadFrom()方法的时候，提供的是程序集的文件名，当将一个程序集添加到项目引用中以后，可以直接写“文件名.dll”。如果想加载一个不属于当前项目的程序集，则需要给出全路径，比如：

Assembly asm = Assembly.LoadFrom(@"C:\\WINDOWS\\Microsoft.NET\\Framework\\v2.0.50727\\System.Web.dll");

使用Load()方法的时候，只用提供程序集名称即可，不需要提供程序集的后缀名。如果想获得当前程序集，可以使用Assembly类型的静态方法 GetExecutingAssembly，它返回包含当前执行的代码的程序集(也就是当前程序集)。

Assembly as = Assembly.GetExecutingAssembly();

在获得一个Type类型实例以后，我们还可以使用该实例的Assembly属性来获得其所在的程序集：

Type t = typeof(int)  
Assembly asm = t.Assembly;

一个程序集可能有多个模块(Module)组成，每个模块又可能包含很多的类型，但.Net的默认编译模式一个程序集只会包含一个模块，我们现在看下 反射 提供了什么样的能力让我们获取关于程序集的信息(只列出了部分常用的)：

<table> 
 <tbody> 
  <tr> 
   <td> <strong>属 性/方 法</strong></td> 
   <td> <strong>说 明</strong></td> 
  </tr> 
  <tr> 
   <td> FullName</td> 
   <td> 程序集名称</td> 
  </tr> 
  <tr> 
   <td> Location</td> 
   <td> 程序集的路径</td> 
  </tr> 
  <tr> 
   <td> GetTypes()</td> 
   <td> 获取程序集包含的全部类型</td> 
  </tr> 
  <tr> 
   <td> GetType()</td> 
   <td> 获取某个类型</td> 
  </tr> 
  <tr> 
   <td> GetModules()</td> 
   <td> 获取程序集包含的模块</td> 
  </tr> 
  <tr> 
   <td> GetModule()</td> 
   <td> 获取某个模块</td> 
  </tr> 
  <tr> 
   <td> GetCustomAttributes()</td> 
   <td> 获取自定义特性信息</td> 
  </tr> 
 </tbody> 
</table>

**NOTE**：程序集和命名空间不存在必然联系，一个程序集可以包含多个命名空间，同一个命名空间也可以分放在几个程序集。

为了方便进行我们后面的测试，我们现在建立一个Windows控制台应用程序，我给它起名叫SimpleExplore；然后再添加一个Demo类库项目，我们将来编写的代码就用户查看这个Demo项目集的类型信息 或者 是对这个程序集中的类型进行迟绑定。这个Demon项目只包含一个命名空间Demo，为了体现尽可能多的类型同时又Keep Simple，其代码如下：

namespace Demo \{  
  
public abstract class BaseClass \{  
  
\}  
  
public struct DemoStruct \{ \}  
  
public delegate void DemoDelegate(Object sender, EventArgs e);  
  
public enum DemoEnum \{  
terrible, bad, common=4, good, wonderful=8  
\}  
  
public interface IDemoInterface \{  
void SayGreeting(string name);  
\}  
  
public interface IDemoInterface2 \{\}  
  
public sealed class DemoClass:BaseClass, IDemoInterface,IDemoInterface2 \{  
  
private string name;  
public string city;  
public readonly string title;  
public const string text = "Const Field";  
public event DemoDelegate myEvent;  
  
public string Name \{  
private get \{ return name; \}  
set \{ name = value; \}  
\}  
  
public DemoClass() \{  
title = "Readonly Field";  
\}  
  
public class NestedClass \{ \}  
  
public void SayGreeting(string name) \{  
Console.WriteLine("Morning :" + name);  
\}  
\}  
  
\}

现在我们在 SimpleExplore项目中写一个方法AssemblyExplor()，查看我们Demo项目生成的程序集Demo.dll定义的全部类型：

public static void AssemblyExplore() \{  
StringBuilder sb = new StringBuilder();  
  
Assembly asm = Assembly.Load("Demo");  
  
sb.Append("FullName(全名)：" + asm.FullName + "\\n");  
sb.Append("Location(路径)：" + asm.Location + "\\n");  
  
Type\[\] types = asm.GetTypes();  
  
foreach (Type t in types) \{  
sb.Append(" 类型：" + t + "\\n");  
\}  
  
Console.WriteLine(sb.ToString());  
\}

然后，我们在Main()方法中调用一下，应该可以看到这样的输出结果：

FullName(全名)：Demo, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null  
Location(路径)：E:\\MyApp\\TypeExplorer\\SimpleExplorer\\bin\\Debug\\Demo.dll  
模块: Demo.dll  
类型：Demo.BaseClass  
类型：Demo.DemoStruct  
类型：Demo.DemoDelegate  
类型：Demo.DemoEnum  
类型：Demo.IDemoInterface  
类型：Demo.IDemoInterface2  
类型：Demo.DemoClass  
类型：Demo.DemoClass+NestedClass

## 反射基本类型 ##

这里说反射基本类型，基本类型是针对 泛型类型 来说的，因为 反射泛型 会更加复杂一些。在前面的范例中，我们获得了程序集中的所有类型，并循环打印了它们，打印结果仅仅显示出了类型的全名，而我们通常需要关于类型更详细的信息，本节我们就来看看如何进一步查看类型信息。

**NOTE**：因为一个程序集包含很多类型，一个类型包含很多成员(方法、属性等)，一个成员又包含很多其他的信息，所以如果我们从程序集层次开始写代码去获取每个层级的信息，那么会嵌套很多的foreach语句，为了阅读方便，我会去掉最外层的循环。

### 1.获取基本信息 ###

有了前面Type一节的介绍，我想完成这里应该只是打打字而已，所以我直接写出代码，如有必要，会在注释中加以说明。我们再写一个方法TypeExplore，用于获取类型的详细信息(记得AssemblyExplore只获取了类型的名称)：

public static void TypeExplore(Type t) \{  
StringBuilder sb = new StringBuilder();  
  
sb.Append("名称信息：\\n");  
sb.Append("Name: " + t.Name + "\\n");  
sb.Append("FullName: " + t.FullName + "\\n");  
sb.Append("Namespace: " + t.Namespace + "\\n");  
  
sb.Append("\\n其他信息：\\n");  
sb.Append("BaseType(基类型): " + t.BaseType + "\\n");  
sb.Append("UnderlyingSystemType: " + t.UnderlyingSystemType + "\\n");  
  
sb.Append("\\n类型信息：\\n");  
sb.Append("Attributes(TypeAttributes位标记): " + t.Attributes + "\\n");  
sb.Append("IsValueType(值类型): " + t.IsValueType + "\\n");  
sb.Append("IsEnum(枚举): " + t.IsEnum + "\\n");  
sb.Append("IsClass(类): " + t.IsClass + "\\n");  
sb.Append("IsArray(数组): " + t.IsArray + "\\n");  
sb.Append("IsInterface(接口): " + t.IsInterface + "\\n");  
sb.Append("IsPointer(指针): " + t.IsPointer + "\\n");  
sb.Append("IsSealed(密封): " + t.IsSealed + "\\n");  
sb.Append("IsPrimitive(基类型): " + t.IsPrimitive + "\\n");  
sb.Append("IsAbstract(抽象): " + t.IsAbstract + "\\n");  
sb.Append("IsPublic(公开): " + t.IsPublic + "\\n");  
sb.Append("IsNotPublic(不公开): " + t.IsNotPublic + "\\n");  
sb.Append("IsVisible: " + t.IsVisible + "\\n");  
sb.Append("IsByRef(由引用传递): " + t.IsByRef + "\\n");  
  
Console.WriteLine(sb.ToString());  
\}

然后，我们在Main方法中输入：

Type t = typeof(DemoClass);  
TypeExplore(t);

会得到这样的输出：

名称信息：  
Name: DemoClass  
FullName: Demo.DemoClass  
Namespace: Demo  
  
其他信息：  
BaseType(基类型): Demo.BaseClass  
UnderlyingSystemType: Demo.DemoClass  
  
类型信息：  
Attributes(TypeAttributes位标记): AutoLayout, AnsiClass, Class, Public, Sealed,  
BeforeFieldInit  
IsValueType(值类型): False  
IsEnum(枚举): False  
IsClass(类): True  
IsArray(数组): False  
IsInterface(接口): False  
IsPointer(指针): False  
IsSealed(密封): True  
IsPrimitive(基类型): False  
IsAbstract(抽象): False  
IsPublic(公开): True  
IsNotPublic(不公开): False  
IsVisible: True  
IsByRef(由引用传递): False

值得注意的是Attributes属性，它返回一个TypeAttributes位标记，这个标记标识了类型的一些元信息，可以看到我们熟悉的Class、Public、Sealed。相应的，IsClass、IsSealed、IsPublic等属性也返回为True。

### 2.成员信息 与 MemberInfo 类型 ###

我们先考虑一下对于一个类型Type，可能会包含什么类型，常见的有字段、属性、方法、构造函数、接口、嵌套类型等。MemberInfo 类代表着 Type的成员类型，值得注意的是Type类本身又继承自MemberInfo类，理解起来并不困难，因为一个类型经常也是另一类型的成员。Type类提供 GetMembers()、GetMember()、FindMember()等方法用于获取某个成员类型。

我们再添加一个方法 MemberExplore()，来查看一个类型的所有成员类型。

public static void MemberExplore(Type t) \{  
StringBuilder sb = new StringBuilder();  
  
MemberInfo\[\] memberInfo = t.GetMembers();  
  
sb.Append("查看类型 " + t.Name + "的成员信息：\\n");  
  
foreach (MemberInfo mi in memberInfo) \{  
sb.Append("成员：" + mi.ToString().PadRight(40) + " 类型: " + mi.MemberType + "\\n");  
\}  
  
Console.WriteLine(sb.ToString());  
\}

然后我们在Main方法中调用一下。

MemberExplore(typeof(DemoClass));

产生的输出如下：

查看类型 DemoClass的成员信息：  
\--------------------------------------------------  
成员：Void add\_myEvent(Demo.DemoDelegate) 类型: Method  
成员：Void remove\_myEvent(Demo.DemoDelegate) 类型: Method  
成员：System.String get\_Name() 类型: Method  
成员：Void set\_Name(System.String) 类型: Method  
成员：Void SayGreeting(System.String) 类型: Method  
成员：System.Type GetType() 类型: Method  
成员：System.String ToString() 类型: Method  
成员：Boolean Equals(System.Object) 类型: Method  
成员：Int32 GetHashCode() 类型: Method  
成员：Void .ctor() 类型: Constructor  
成员：System.String Name 类型: Property  
成员：Demo.DemoDelegate myEvent 类型: Event  
成员：System.String text 类型: Field  
成员：Demo.DemoClass+NestedClass 类型: NestedType

我们使用了GetMembers()方法获取了成员信息的一个数组，然后遍历了数组，打印了成员的名称和类型。如同我们所知道的：Name属性在编译后成为了get\_Name()和set\_Name()两个独立的方法；myEvent事件的注册(+=)和取消注册(-=)分别成为了add\_myEvent()和remove\_myEvent方法。同时，我们发现私有(private)字段name 没有被打印出来，另外，基类System.Object的成员GetType()和Equals()也被打印了出来。

有的时候，我们可能不希望查看基类的成员，也可能希望查看私有的成员，此时可以使用GetMembers()的重载方法，传入BindingFlags 位标记参数来完成。BindingFlags位标记对如何获取成员的方式进行控制(也可以控制如何创建对象实例，后面会说明)。对于本例，如果我们想获取所有的公有、私有、静态、实例 成员，那么只需要这样修改GetMembers()方法就可以了。

MemberInfo\[\] memberInfo = t.GetMembers(  
BindingFlags.Public |  
BindingFlags.Static |  
BindingFlags.NonPublic |  
BindingFlags.Instance |  
BindingFlags.DeclaredOnly  
);

此时的输出如下：

查看类型 DemoClass的成员信息：  
\--------------------------------------------------  
成员：Void add\_myEvent(Demo.DemoDelegate) 类型: Method  
成员：Void remove\_myEvent(Demo.DemoDelegate) 类型: Method  
成员：System.String get\_Name() 类型: Method  
成员：Void set\_Name(System.String) 类型: Method  
成员：Void SayGreeting(System.String) 类型: Method  
成员：Void .ctor() 类型: Constructor  
成员：System.String Name 类型: Property  
成员：Demo.DemoDelegate myEvent 类型: Event  
成员：System.String name 类型: Field  
成员：Demo.DemoDelegate myEvent 类型: Field  
成员：System.String text 类型: Field  
成员：Demo.DemoClass+NestedClass 类型: NestedType

可以看到，继承自基类 System.Object 的方法都被过滤掉了，同时，打印出了私有的 name, myEvent 等字段。

现在如果我们想要获取所有的方法(Method)，那么我们可以使用 Type类的FindMembers()方法：

MemberInfo\[\] memberInfo = t.FindMembers(  
MemberTypes.Method, // 说明查找的成员类型为 Method  
BindingFlags.Public |  
BindingFlags.Static |  
BindingFlags.NonPublic |  
BindingFlags.Instance |  
BindingFlags.DeclaredOnly,  
Type.FilterName,  
"\*"  
);

Type.FilterName 返回一个MemberFilter类型的委托，它说明按照方法名称进行过滤，最后一个参数“\*”，说明返回所有名称(如果使用“Get\*”，则会返回所有以Get开头的方法)。现在的输出如下：

MemberInfo 类有两个属性值得注意，一个是DeclaringType，一个是 ReflectedType，返回的都是Type类型。DeclaredType 返回的是声明该成员的类型。比如说，回顾我们之前的一段代码：

MemberInfo\[\] members = typeof(DemoClass).GetMembers();

它将返回所有的公有成员，包括继承自基类的Equals()等方法，对于Equals()方法来说，它的 DeclaringType 返回的是相当于 typeof(Object) 的类型实例，因为它是在 System.Object中被定义的；而它的ReflectedType 返回的则是相当于 typeof(DemoClass) 类型实例，因为它是通过 DemoClass 的类型实例被获取的。

### 3.字段信息 与 FieldInfo类型 ###

如同我们之前所说，MemberInfo 是一个基类，它包含的是类型的各种成员都公有的一组信息。实际上，对于字段、属性、方法、事件 等类型成员来说，它们包含的信息显然都是不一样的，所以，.Net 中提供了 FiledInfo 类型来封装字段的信息，它继承自MemberInfo。

如果我们希望获取一个类型的所有字段，可以使用 GetFileds()方法。我们再次添加一个方法FieldExplore()：

public static void FieldExplore(Type t) \{  
StringBuilder sb = new StringBuilder();  
  
FieldInfo\[\] fields = t.GetFields();  
  
sb.Append("查看类型 " + t.Name + "的字段信息：\\n");  
sb.Append(String.Empty.PadLeft(50, '-') + "\\n");  
  
foreach (FieldInfo fi in fields) \{  
sb.Append("名称：" + fi.Name + "\\n");  
sb.Append("类型：" + fi.FieldType + "\\n");  
sb.Append("属性：" + fi.Attributes + "\\n\\n");  
\}  
  
Console.WriteLine(sb.ToString());  
\}

产生的输出如下：

查看类型 DemoClass的字段信息：  
\--------------------------------------------------  
名称：city  
类型：System.String  
属性：Public  
  
名称：title  
类型：System.String  
属性：Public, InitOnly  
  
名称：text  
类型：System.String  
属性：Public, Static, Literal, HasDefault

值得一提的是fi.FieldType 属性，它返回一个FieldAttributes位标记，这个位标记包含了字段的属性信息。对比我们之前定义的DemoClass类，可以看到，对于title 字段，它的属性是public, InitOnly；对于Const类型的text字段，它的属性为Public,Static,Literal，HasDefault，由此也可以看出，声明一个const类型的变量，它默认就是静态static的，同时，由于我们给了它初始值，所以位标记中也包括HasDefault。

针对于FieldType位标记，FiledInfo 类提供了一组返回为bool类型的属性，来说明字段的信息，常用的有：IsPublic, IsStatic, IsInitOnly, IsLiteral, IsPrivate 等。

如果我们想要获取私有字段信息，依然可以使用重载了的GetFields\[\]方法，传入BindingFlags参数，和上面的类似，这里就不重复了。

### 4.属性信息 与 PropertyInfo 类型 ###

和字段类似，也可以通过 GetProperty()方法，获取类型的所有属性信息。

public static void PropertyExplore(Type t) \{  
StringBuilder sb = new StringBuilder();  
sb.Append("查看类型 " + t.Name + "的属性信息：\\n");  
sb.Append(String.Empty.PadLeft(50, '-') + "\\n");  
  
PropertyInfo\[\] properties = t.GetProperties();  
  
foreach (PropertyInfo pi in properties) \{  
sb.Append("名称：" + pi.Name + "\\n");  
sb.Append("类型：" + pi.PropertyType + "\\n");  
sb.Append("可读：" + pi.CanRead + "\\n");  
sb.Append("可写：" + pi.CanWrite +"\\n");  
sb.Append("属性：" + pi.Attributes +"\\n");  
\}  
  
Console.WriteLine(sb.ToString());  
\}

输出如下：

查看类型 DemoClass的属性信息：  
\--------------------------------------------------  
名称：Name  
类型：System.String  
可读：True  
可写：True  
属性：None

从前面的章节可以看到，Name属性会在编译后生成Get\_Name()和Set\_Name()两个方法，那么，应该可以利用反射获取这两个方法。PropertyInfo类的GetGetMethod()和GetSetMethod()可以完成这个工作，它返回一个MethodInfo对象，封装了关于方法的信息，我们会在后面看到。

### 5.方法信息 与 MethodInfo 类型 ###

与前面的类似，我们依然可以编写代码来查看类型的方法信息。

public static void MethodExplore(Type t) \{  
StringBuilder sb = new StringBuilder();  
sb.Append("查看类型 " + t.Name + "的方法信息：\\n");  
sb.Append(String.Empty.PadLeft(50, '-') + "\\n");  
  
MethodInfo\[\] methods = t.GetMethods();  
  
foreach (MethodInfo method in methods) \{  
sb.Append("名称：" + method.Name +"\\n");  
sb.Append("签名：" + method.ToString() + "\\n");  
sb.Append("属性：" + method.Attributes + "\\n");  
sb.Append("返回值类型：" + method.ReturnType + "\\n\\n");  
\}  
  
Console.WriteLine(sb.ToString());  
\}

与前面类似，MethodInfo 类也有一个Attributes属性，它返回一个MethodAttribute，MethodAttribute 位标记标明了方法的一些属性，常见的比如Abstract, Static, Virtual,Public, Private 等。

与前面不同的是，Method可以具有参数 和 返回值，MethodInfo 类提供了 GetParameters() 方法获取 参数对象的数组，方法的参数都封装在了 ParameterInfo 类型中。查看ParameterInfo类型的方法与前面类似，这里就不再阐述了。

### 4. ConstructorInfo类型、EventInfo 类型 ###

从名称就可以看出来，这两个类型封装了类型 的构造函数 和 事件信息，大家都是聪明人，查看这些类型与之前的方法类似，这里就不再重复了。

### 5.小结 ###

本文涉及了反射的最基础的内容，我们可以利用反射来自顶向下地查看程序集、模块、类型、类型成员的信息。反射更强大、也更有意思的内容：迟绑定方法、动态创建类型以后会再讲到。

转载于:https://www.cnblogs.com/JimmyZhang/archive/2008/02/17/1071372.html