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>
