C# 反射机制的学习心得

首先说说，为什么要学习 反射 呢？有什么用啊。

在我们写程序的时候，经常会用到一些类中的方法，那么就要调用这些个类。如果不是在一个命名空间里时，就要引用相应的dll文件，然后再读取类中的方法。可是这样一来就很麻烦，因为记不住所有的类的地址啊，使用很不方便。

这时候就体现出反射了，我们不知道类在哪里，但是依然可以使用，只要知道名字，通过反射就可以得到地址信息，进行调用。

反射可以动态的创建类型实例，再绑定到现有对象上。

从特定的程序集里载入特定的类型，以创建特定的实例。

反射的特性就是动态的建立实例，但是它的弊端就是要牺牲一些性能，并且有些属性信息是不能通过反射来得到的。



反射 是.Net中获取运行时类型信息的方式，.Net的应用程序由几个部分：‘程序集(Assembly)’、‘模块(Module)’、‘类型(class)’组成，而反射提供一种编程的方式，让程序员可以在程序运行期获得这几个组成部分的相关信息，例如：

Assembly类可以获得正在运行的装配件信息，也可以动态的加载装配件，以及在装配件中查找类型信息，并创建该类型的实例。

所有要素：方法、构造器、属性等等，通过Type类可以得到这些要素的信息，并且调用之。

Type类可以获得对象的类型信息，此信息包含对象的MethodInfo包含方法的信息，通过这个类可以得到方法的名称、参数、返回值等，并且可以调用之。

诸如此类，还有FieldInfo、EventInfo等等，这些类都包含在System.Reflection命名空间下。

命名空间与装配件的关系
很多人对这个概念可能还是很不清晰，对于合格的.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。

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

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

public static void test1()
{
// Loads an assembly using its file name.
Assembly a = Assembly.LoadFrom(@"F:\Documents and Settings\v-yahuan\Desktop\ttt\TestRun0501\WinApp\bin\Debug\WinApp.exe");
// Gets the type names from the assembly.
Type[] types2 = a.GetTypes();
foreach (Type t in types2)
{
Console.WriteLine(t.FullName);
foreach (MemberInfo m in t.GetMethods())
{
Console.WriteLine("methods " + m.Name);
}
}
Console.WriteLine();
}

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

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

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

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);//反射不仅仅是获取信息，还可以调用类中的方法。

//不妨试试，在以后某个类中要想调用某个类的函数、属性时就通过反射来实现下。

　　动态创建委托

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

　　

再来个完整的例子吧：

using System;
using System.Collections.Generic;
using System.Linq; using System.Text;
namespace SKY.ReflectDemo
{
public class ReflectTest : IPerson
{
private string _name;
private int _age;
public string Name
{
get { return this._name; }
set { this._name = value; }
}
public int Age
{
get { return this._age; }
set { this._age = value; }
}
public ReflectTest(string name, int age) {
this._name = name;
this._age = age;
}
public string WelcomeInfo(string name) {
return "welcome come here " + name;
}
public static string WriteStaticInfo(string name) {
return "welcome come here static" + name;
}
public static string WriteStaticNoParam() {
return "Static and No parma";
}
public void Show(string info) {
Console.WriteLine(info);
}
public ReflectTest() { }
public string WriteNoPara() {
return "你使用的是无参的方法";
}
private string WritePrivate() {
return "私有类型的方法";
}
#region IPerson 成员
public int Add() {
return Age;
}
#endregion
}
public interface IPerson {
/// <summary> /// 添加对象 /// </summary> /// <returns></returns> int Add();
}
}

　　

　然后再创建一个客户端程序：例如clientTestDemo,添加刚刚新建的程序集引用，引用命名空间using System.Reflection

class Program {

delegate string TestDelegate(string name); static void Main(string[] args) {
//*********************引导程序集************************//
//Assembly ass =Assembly.LoadFrom(("SKY.ReflectDemo.dll"));
//Assembly ass=Assembly.GetAssembly(typeof(SKY.ReflectDemo.ReflectTest);
Assembly ass = Assembly.Load("SKY.ReflectDemo");//功能同上   载入程序集
Console.Write(ass.FullName+"\n");
//*********************显示该dll下所有的类***************//
foreach (Type type in ass.GetTypes()) { Console.Write(type.Name+"\n"); }
//*********************显示该dll下指定类**************//
Type itype = ass.GetType("SKY.ReflectDemo.ReflectTest");  读取程序集中的类
Console.Write(itype.Name);
Type itype1 = typeof(SKY.ReflectDemo.ReflectTest);
//********************所有模块***********************//
foreach (Module temp in ass.GetModules())
{
Console.WriteLine(temp.Assembly.FullName);
}
//********************创建该类的实例,后面的param为有参构造函数的参数******************//
object[] param = { "test", 30 };//构造函数参数     带参数的构造函数
SKY.ReflectDemo.ReflectTest temp1 = (SKY.ReflectDemo.ReflectTest)Activator.CreateInstance(itype1, param); 实例
// SKY.ReflectDemo.ReflectTest temp1 = (SKY.ReflectDemo.ReflectTest)ass.CreateInstance("SKY.ReflectDemo.ReflectTest");
Console.WriteLine(temp1.WriteNoPara());
//******************************显示所有的共有方法************************************//
MethodInfo[] methods = itype.GetMethods();   遍历读取所有的方法名字
Console.WriteLine("------------------------显示所有的共有方法-------------------------");
foreach (MethodInfo temp in methods) { Console.WriteLine(temp.Name); }  输出方法名字
//******************************显示特定方法************************************//
Console.WriteLine("------------------------显示特定方法------------------------------");
MethodInfo method1 = itype.GetMethod("WriteStaticInfo"); //带参的静态方法   读取特定名字的方法
Console.WriteLine(method1.Name);
object[] param1 = { "使用的是静态方法" };
string s1 = (string)method1.Invoke(null, param1);   使用带有参数的方法（不用实例直接使用方法）
Console.WriteLine("执行后:"+s1+"\n");
MethodInfo method2 = itype.GetMethod("WriteStaticNoParam");//无参静态方法
Console.WriteLine(method2.Name);
string s2 = method2.Invoke(null, null) as string; 使用无参数的方法（不用实例直接使用方法）
Console.WriteLine("执行后:" + s2 + "\n");
MethodInfo method3 = itype.GetMethod("WelcomeInfo");//带参的非静态方法
Console.WriteLine(method3.Name);
object[] param2 = { "使用的是带有参数的非静态方法" };
string s3 = (string)method3.Invoke(temp1, param2); 使用带参数的静态方法
Console.WriteLine("执行后:" + s3 + "\n");
MethodInfo method4 = itype.GetMethod("WriteNoPara");//无参非静态方法
Console.WriteLine(method4.Name);
string s4 = method4.Invoke(temp1, null) as string;  使用无参数的静态方法 temp1实例
Console.WriteLine("执行后:" + s4 + "\n");
MethodInfo method5 = itype.GetMethod("WritePrivate", BindingFlags.NonPublic | BindingFlags.Instance);//无参私有非静态方法
Console.WriteLine(method5.Name);
string s5 = method5.Invoke(temp1, null) as string; Console.WriteLine("执行后:" + s5 + "\n");
MethodInfo method6 = itype.GetMethod("Show");//返回类型为void的方法
Console.WriteLine(method6.Name);
object[]param3={"returnType is void"};
string s6 = method6.Invoke(temp1, param3) as string;
Console.WriteLine(s6);
//***********************************显示所有属性*********************************88//
Console.WriteLine("------------------------显示所有属性------------------------------");
PropertyInfo[] pros = itype.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (PropertyInfo temp in pros) { Console.WriteLine(temp.Name); } //***********************************显示特定属性*********************************88//
Console.WriteLine("------------------------显示特定属性------------------------------");
PropertyInfo proName = itype.GetProperty("Name");
proName.SetValue(temp1, "testName",null);
Console.WriteLine(proName.GetValue(temp1, null));
//***********************************显示构造函数*********************************88//
Console.WriteLine("------------------------显示构造函数------------------------------");
ConstructorInfo[] cons = itype.GetConstructors();
foreach (ConstructorInfo t in cons) { Console.WriteLine(t.ToString()); }
//***********************************显示特定构造函数形式*********************************88//
Console.WriteLine("------------------------显示特定构造函数形式------------------------------");
ConstructorInfo con1= itype.GetConstructor(new Type[] { typeof(string), typeof(int) });
Console.WriteLine(con1); ConstructorInfo con2 = itype.GetConstructor(new Type[] { });
Console.WriteLine(con2);
//**************************************委托的使用*********************************************//
Console.WriteLine("------------------------委托的使用------------------------------");
TestDelegate td = (TestDelegate)Delegate.CreateDelegate(typeof(TestDelegate), temp1, "WelcomeInfo");//非静态方法
Console.WriteLine(td("使用的是带有参数的非静态方法"));
TestDelegate td2 = Delegate.CreateDelegate(typeof(TestDelegate), method1) as TestDelegate;//静态方法
Console.WriteLine(td2("使用静态方法"));
// TestDelegate td1 = new TestDelegate(SKY.ReflectDemo.ReflectTest.WriteStaticInfo);
// Console.WriteLine(td1("使用的是带有参数的非静态方法222")); 同上

　　也可以动态的读取配置文件来初始化类实例

Assembly a = Assembly.Load("SKY.ReflectDemo");

String carString = System.Configuration.ConfigurationManager.AppSettings["car"];
Type t = a.GetType(carString);
RefluctTest car2 = (RefluctTest)Activator.CreateInstance(t);

　　car的配置文件中数据就是 类名SKY.ReflectDemo.ReflectTest

配置文件的内容：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="car" value="SKY.ReflectDemo.ReflectTest" />
</appSettings>
</configuration>