C#反射机制总结

注：所有的内容都来自互联网，感谢作者的无私贡献。

1.什么是反射
Reflection，中文翻译为 反射。
这是.Net中获取 运行时类型信息的方式，.Net的应用程序由几个部分：'程序集(Assembly)’、'模块(Module)’、'类型(class)’组成，而反射提供一种编程的方式，让程序员可以在程序运行期获得这几个组成部分的相关信息，例如：
通常程序员面试题，有这样关于反射的解释：反射可以动态地创建类型的实例，还可以将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。
Assembly类可以获得正在运行的装配件信息，也可以动态的加载装配件，以及在装配件中查找类型信息，并创建该类型的实例。
Type类可以获得对象的类型信息，此信息包含对象的所有要素：方法、构造器、属性等等，通过Type类可以得到这些要素的信息，并且调用之。
MethodInfo包含方法的信息，通过这个类可以得到方法的名称、参数、返回值等，并且可以调用之。
诸如此类，还有FieldInfo、PropertyInfo、ConstructorInfo、EventInfo等等，这些类都包含在System.Reflection命名空间。

2.命名空间与装配件的关系

很多人对这个概念可能还是很不清晰，对于合格的.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。
到这里，我们可以清楚一个概念了，命名空间只是说明一个类型是那个族的，比如有人是汉族、有人是回族；而装配件表明一个类型住在哪里，比如有人住在北京、有人住在上海；那么北京有汉族人，也有回族人，上海有汉族人，也有回族人，这是不矛盾的。

上面我们说了，装配件是一个类型居住的地方，那么在一个程序中要使用一个类，就必须告诉编译器这个类住在哪儿，编译器才能找到它，也就是说必须引用该装配件。
问题出现了：如果在编写程序的时候，也许不确定这个类在哪里，仅仅只是知道它的名称，就不能使用了吗？答案是可以，这就是反射了，就是在程序运行的时候提供该类型（class）的全地址，而去找到它。

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

有人也许疑问，既然在开发时就能够写好代码，干嘛还放到运行期去做，不光繁琐，而且效率也受影响。
这就是个见仁见智的问题了，就跟早绑定和晚绑定一样，应用到不同的场合。有的人反对晚绑定，理由是损耗效率，但是很多人在享受虚函数带来的好处的时侯还没有意识到他已经用上了晚绑定。这个问题说开去，不是三言两语能讲清楚的，所以就点到为止了。
我的看法是，晚绑定能够带来很多设计上的便利，合适的使用能够大大提高程序的复用性和灵活性，但是任何东西都有两面性，使用的时侯，需要再三衡量。
接着说，运行期得到类型信息到底有什么用呢？
还是举个例子来说明，很多软件开发者喜欢在自己的软件中留下一些接口，其他人可以编写一些插件（程序集（dll等））来扩充该软件的功能，比如我开发了一个销售图书的电子商务系统，其中的两个业务
一是：新增加购买订单；
二是，根据订单的唯一标识号获取某一订单信息。
我希望以后可以很方便的扩展到多种数据库管理系统中（MS SQL SERVER, Oracle等）来完成相关业务，那么我需要声明一个接口：
/// <summary>
/// Interface for the Order DAL
/// </summary>
public interface IOrder
{
// Property 表示该系统业务采用什么类型的数据，MS SQL or Oracle 等等
string DataBaseType
{
get;
}
/// <summary>
/// Method to insert an order header
/// </summary>
/// <param name="order">Business entity representing the order</param>
/// <returns>OrderId</returns>
void Insert(OrderInfo order);

/// <summary>
/// Reads the order information for a given orderId
/// </summary>
/// <param name="orderId">Unique identifier for an order</param>
/// <returns>Business entity representing the order</returns>
OrderInfo GetOrder(int orderId);
}

实体类（OrderInfo）
/**//// <summary>
/// Business entity used to model an order
/// </summary>
public class OrderInfo
{
private int orderId;
private DateTime date;
private string userId;
private string orderNo;
private string courierWay;
private string paymentWay;

/**//// <summary>
/// 订单ID
/// </summary>
public int OrderId
{
get { return orderId; }
set { orderId = value; }
}
/**//// <summary>
/// 订单提交日期
/// </summary>
public DateTime Date
{
get { return date; }
set { date = value; }
}
/**//// <summary>
/// 用户ID
/// </summary>
public string UserId
{
get { return userId; }
set { userId = value; }
}
/**//// <summary>
/// 订单编号
/// </summary>
public string OrderNo
{
get { return orderNo; }
set { orderNo = value; }
}
/**//// <summary>
/// 配送方式
/// </summary>
public string CourierWay
{
get { return courierWay; }
set { courierWay = value; }
}
/**//// <summary>
/// 支付方式
/// </summary>
public string PaymentWay
{
get { return paymentWay; }
set { paymentWay = value; }
}
}

这个接口中包含:
（1）一个DataBaseType属性，这个属性返回扩展的或是要支持的数据库管理系统的标识或描述，这样就可以知道是使用那个数据库系统，根据Web.config提取相关了（不明白就往下走）;
（2）第一个方法（Insert（OrderInfo order））（这里我定义了一个OrderInfo类(实体)，这个类（实体对象）提供对数据的封装，在这里，简单地说就是将订单的相关信息（见实体类中定义的属性），封装在该实体类创建的实体对象中，作为该插入（Insert）新纪录的参数。
（3）第二个方法（GetOrder（int orderId）） 这个方法由提供的订单Id（orderId）从数据库中，读取相关数据，记录在创建的OrderInfo实体对象中，通过该实体对象的属性可以读取相关信息，如订单生成日期，金额，发送地址等；

那么我规定所有的数据访问逻辑（基于基于某一数据库系统）都必须派生一个数据库访问层，并且实现这个接口，在定义的方法中返回处理处理Code对象，并且可以指定，数据库类型的描述（如DBMS Name）。
这样的话，我就不需要在开发系统时知道将来需要采用的数据系统类型（是采用Ms SqlServer 呢？还是采用Oracle呢？等等），只需要从配置文件中获取现在所指定的数据库系统的描述，就可以动态的创建对象，将其转换为IOrder接口来使用。

4.通过一个Demo演示，一个对象的实例泄漏的秘密（这是我从别人那看来的）
class Program
{
static void Main(string[] args)
{
classA a=new classA();
TestObjectType test =new TestObjectType();
Test.FucType(a);
}
}

class classA
{
internal int iNumberA = 100;
public int iNumberB = 200;
private int property;

public int Property
{
get
{
return property;
}
set
{
property = value;
}
}
public void FunA()
{
Console.WriteLine("classA is a Fuction! ");
}
}

class classB
{

}

class TestObjectType
{
internal void FucType(object A)
{
Type objType = A.GetType();

Assembly objassembly = objType.Assembly;
Type[] types = objassembly.GetTypes();
foreach (Type type in types)
{
Console.WriteLine("类名 " + type.FullName);

// 获取类型的结构信息
ConstructorInfo[] myConstructor = type.GetConstructors();
Show(myConstructor);

// 获取类型的字段信息
FieldInfo[] myField = type.GetFields();
Show(myField);

// 获取方法的方法
MethodInfo[] myMethod = type.GetMethods();
Show(myMethod);

// 获取属性的方法
PropertyInfo[] myProperty = type.GetProperties();
Show(myProperty);

// 获取事件信息，这个Demo没有事件，所以就不写了 EventInfo
}
Console.ReadLine();
}

// 显示数组的基本信息
private void Show(object[] myObject)
{
foreach (object var in myObject)
{
Console.WriteLine(var.ToString());
}
Console.WriteLine("-------------------");
}
}

运行结果如下图所示：



但是，测试分析后，发现其实也只能获得public 类型的信息

5.动态创建对象实例的基础
是实现抽象工厂的基础,也是实现抽象工厂的核心技术,通过它,可以动态创建一个你想要的对象.
如下面的例子是演示如何动态创建ChineseName或EnglishName的实例。

这个Demo和3中讲到的Demo如出一辙，这个更简化些（用C#控制台应用程序 编写的），并提供完整的动态创建对象的代码，读者对照两者揣摩加联系。其实都很简单。
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace TestReflection
{
class Program
{
static void Main(string[] args)
{
IName objChineseName = AbstractFactory.createChineseName();
objChineseName.ShowName();

IName objEnglishName = AbstractFactory.createChineseName();
objEnglishName.ShowName();
}
}

// 声明一个接口，它有一个显示"名字"的功能(ShowName方法)
public interface IName
{
void ShowName();
}

// 实现接口，显示中国名字
public class ChineseName : IName
{
#region 成员函数

public void ShowName()
{
Console.WriteLine("我叫XX!");
Console.ReadLine();
}

#endregion
}

// 实现接口，显示中国名字
public class EnglishName : IName
{
#region 成员函数

public void ShowName()
{
Console.WriteLine("My name is XX a!");
Console.ReadLine();
}

#endregion
}

// 最为重要的代码段，往下看
// 使用抽象工厂的方法来进行动态创建对象实例应用哦

public sealed class AbstractFactory
{
public static readonly string path = "TestReflection";

public static IName createChineseName()
{
// s 的值以后从Web.Config动态读取,如下所示
/*
<appSettings>
<add key="WebDAL" value="[类的全路径]"/>
<appSettings>
*/
// 把className赋值为：TestReflection.ChineseName,将显示中文名
string className = path + ".ChineseName";
return (IName)Assembly.Load(path).CreateInstance(className);
}

public static IName createEnglishName()
{
string className = path + ".EnglishName";
return (IName)Assembly.Load(path).CreateInstance(className);
}
}
}

6.获得整个解决方案的所有Assembly
如果你不太清楚自己的解决方案中都用到了哪些Assembly,可以使用下面的方法,如果再想得到Assembly里的信息，请参见 4

namespace TestReflection
{
class Program
{
static void Main(string[] args)
{
// 遍历显示每个Assembly的名字
foreach (object var in Ax)
{
Console.WriteLine("Assembly的名字是： " + var.ToString());

// 使用一个已知的Assembly的名称，来创建一个Assembly
// 通过CodeBase属性显示最初指定的程序集的位置
Console.WriteLine("最初指定的程序集TestReflection的位置： " + Assembly.Load("TestReflection").CodeBase);
Console.ReadLine();
}
}
}
}

【补充：】
1、如何使用反射获取类型
首先我们来看如何获得类型信息。
获得类型信息有两种方法，一种是得到实例对象
这个时侯我仅仅是得到这个实例对象，得到的方式也许是一个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");
原因如下：
Type.GetType属于Reflection的一部分，Reflection可以用于动态解析类型。也就是说，即使编译开发期间没有建立对Assembly的引用，Type.GetType一样可以用于取得类型信息（相反，typeof是静态解析类型的，所以要求reference)。

如果你理解Namespace和Assembly的关系的话，就会明白单从类型的名称（包括Namespace部分）是不可能找到类型定义的，还必须知道定义类型的Assembly的名称和位置。所以在调用Type.GetType的时候必须要附带指明Assembly的信息。

> > 但我想不通了 为什么他们的实例GetType就可以呢？？？
Object.GetType的工作方式和上面的不同。因为你已经得到了对象实例（object)，也就意味着在这之前你已经通过某种方式把定义对象的Assembly加载捣内存里了，不需要额外的信息来确定定义类型的Assembly。

如果是当前的Assembly或者默认的Assembly(mscorlib)，GetType的时候是不需要指定Assembly的，除此之外，都必须指定Assembly的名字，也就是Type的属性AssemblyQualifiedName所代表的值。

对于String：
Type t =
Type.GetType("System.String,mscorlib,Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089 ");
因为属于mscorlib，所以也可以：t = Type.GetType( "System.String ");
但SqlDataAdapter必须指定Assembly名：
t=Type.GetType("System.Data.SqlClient.SqlDataAdapter,System.Data,Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 ");

2、如何根据类型来动态创建对象
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数组中即可

3、如何获取方法以及动态调用方法
namespace TestSpace
{
public class TestClass
{
private string _value;

#region Constructors
public TestClass()
{ }

public TestClass(string value)
{
_value = value;
}
#endregion

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

3、动态创建委托
委托是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”);