C#反射相关

夜色。

于 2013-09-22 19:55:19 发布

阅读量918

点赞数

分类专栏： C#技术内幕

C#技术内幕专栏收录该内容

48 篇文章

订阅专栏

反射的定义：审查元数据并收集关于它的类型信息的能力。元数据（编译以后的最基本数据单元）就是一大堆的表，当编译程序集或者模块时，编译器会创建一个类定义表，一个字段定义表，和一个方法定义表等。
System.reflection命名空间包含的几个类，允许你反射（解析）这些元数据表的代码

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

（注：层次间都是一对多的关系）

反射的作用：
1、可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型
2、应用程序需要在运行时从某个特定的程序集中载入一个特定的类型，以便实现某个任务时可以用到反射。
3、反射主要应用与类库，这些类库需要知道一个类型的定义，以便提供更多的功能。

应用要点：
1、现实应用程序中很少有应用程序需要使用反射类型
2、使用反射动态绑定需要牺牲性能
3、有些元数据信息是不能通过反射获取的
4、某些反射类型是专门为那些clr 开发编译器的开发使用的，所以你要意识到不是所有的反射类型都是适合每个人的。

反射appDomain 的程序集：

当你需要反射AppDomain 中包含的所有程序集，示例如下：
static void Main
{
       //通过GetAssemblies 调用appDomain的所有程序集
       foreach (Assembly assem in Appdomain.currentDomain.GetAssemblies())
      {
       //反射当前程序集的信息
            reflector.ReflectOnAssembly(assem)
      }
}

说明：调用AppDomain 对象的GetAssemblies 方法将返回一个由System.Reflection.Assembly元素组成的数组。

反射单个程序集：

上面的方法讲的是反射AppDomain的所有程序集，我们可以显示的调用其中的一个程序集，system.reflecton.assembly 类型提供了下面三种方法：
1、Load 方法：极力推荐的一种方法，Load 方法带有一个程序集标志并载入它，Load 将引起CLR把策略应用到程序集上，先后在全局程序集缓冲区，应用程序基目录和私有路径下面查找该程序集，如果找不到该程序集系统抛出异常
2、LoadFrom 方法：传递一个程序集文件的路径名（包括扩展名），CLR会载入您指定的这个程序集，传递的这个参数不能包含任何关于版本号的信息，区域性，和公钥信息，如果在指定路径找不到程序集抛出异常。
3、LoadWithPartialName：永远不要使用这个方法，因为应用程序不能确定再在载入的程序集的版本。该方法的唯一用途是帮助那些在.Net框架的测试环节使用.net 框架提供的某种行为的客户，这个方法将最终被抛弃不用。

注意：system.AppDomain 也提供了一种Load 方法，他和Assembly的静态Load 方法不一样，AppDomain的load 方法是一种实例方法，返回的是一个对程序集的引用，Assembly的静态Load 方发将程序集按值封装发回给发出调用的AppDomain.尽量避免使用AppDomain的load 方法

利用反射获取类型信息：

前面讲完了关于程序集的反射，下面在讲一下反射层次模型中的第三个层次，类型反射
一个简单的利用反射获取类型信息的例子：

using system;
using sytem.reflection;
class reflecting
{
       static void Main(string[]args)
       {
             reflecting reflect=new reflecting();//定义一个新的自身类
             //调用一个reflecting.exe程序集

             assembly myAssembly =assembly.loadfrom(“reflecting.exe”)
             reflect.getreflectioninfo(myAssembly);//获取反射信息
       }

       //定义一个获取反射内容的方法
       void getreflectioninfo(assembly myassembly)
       {
             type[] typearr=myassemby.Gettypes();//获取类型
             foreach (type type in typearr)//针对每个类型获取详细信息
            {
                   //获取类型的结构信息
                  constructorinfo[] myconstructors=type.GetConstructors;

//获取类型的字段信息
fieldinfo[] myfields=type.GetFiedls()

//获取方法信息
MethodInfo myMethodInfo=type.GetMethods();

//获取属性信息
propertyInfo[] myproperties=type.GetProperties

                 //获取事件信息
                 EventInfo[] Myevents=type.GetEvents;
           }
      }
}
其它几种获取type对象的方法：
1、System.type   参数为字符串类型，该字符串必须指定类型的完整名称（包括其命名空间）
2、System.type 提供了两个实例方法：GetNestedType,GetNestedTypes
3、Syetem.Reflection.Assembly 类型提供的实例方法是：GetType,GetTypes,GetExporedTypes
4、System.Reflection.Moudle 提供了这些实例方法：GetType,GetTypes,FindTypes

设置反射类型的成员：

反射类型的成员就是反射层次模型中最下面的一层数据。我们可以通过type对象的GetMembers 方法取得一个类型的成员。如果我们使用的是不带参数的GetMembers，它只返回该类型的公共定义的静态变量和实例成员，我们也可以通过使用带参数的 GetMembers通过参数设置来返回指定的类型成员。具体参数参考msdn 中system.reflection.bindingflags 枚举类型的详细说明。

例如：
//设置需要返回的类型的成员内容
bindingFlags bf=bingdingFlags.DeclaredOnly|bingdingFlags.Nonpublic|BingdingFlags.Public;
foreach (MemberInfo mi int t.getmembers(bf))
{
writeline(mi.membertype) //输出指定的类型成员
}

通过反射创建类型的实例：

通过反射可以获取程序集的类型，我们就可以根据获得的程序集类型来创建该类型新的实例，这也是前面提到的在运行时创建对象实现晚绑定的功能
我们可以通过下面的几个方法实现：
1、System.Activator 的CreateInstance方法。该方法返回新对象的引用。具体使用方法参见msdn
2、System.Activator 的createInstanceFrom 与上一个方法类似，不过需要指定类型及其程序集
3、System.Appdomain 的方法：createInstance,CreateInstanceAndUnwrap,CreateInstranceFrom和CreateInstraceFromAndUnwrap
4、System.type的InvokeMember实例方法：这个方法返回一个与传入参数相符的构造函数，并构造该类型。
5、System.reflection.constructinfo 的Invoke实例方法

反射类型的接口：

如果你想要获得一个类型继承的所有接口集合，可以调用Type的FindInterfaces GetInterface或者GetInterfaces。所有这些方法只能返回该类型直接继承的接口，他们不会返回从一个接口继承下来的接口。要想返回接口的基础接口必须再次调用上述方法。

反射的性能：

使用反射来调用类型或者触发方法，或者访问一个字段或者属性时clr 需要做更多的工作：校验参数，检查权限等等，所以速度是非常慢的。所以尽量不要使用反射进行编程，对于打算编写一个动态构造类型（晚绑定）的应用程序，可以采取以下的几种方式进行代替：
1、通过类的继承关系。让该类型从一个编译时可知的基础类型派生出来，在运行时生成该类型的一个实例，将对其的引用放到其基础类型的一个变量中，然后调用该基础类型的虚方法。
2、通过接口实现。在运行时，构建该类型的一个实例，将对其的引用放到其接口类型的一个变量中，然后调用该接口定义的虚方法。
3、通过委托实现。让该类型实现一个方法，其名称和原型都与一个在编译时就已知的委托相符。在运行时先构造该类型的实例，然后在用该方法的对象及名称构造出该委托的实例，接着通过委托调用你想要的方法。这个方法相对与前面两个方法所作的工作要多一些，效率更低一些。

个人操作方案：

源DLL类：

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Web.UI;
using System.Collections;

namespace cn.SwordYang
{

public class TextClass:System.Web.UI.Page
{

public static void RunJs(Page _page, string Source)
        {
            _page.ClientScript.RegisterStartupScript(_page.GetType(), "", "<script type=\"text/javascript\">" + Source + ";</script>");

        }

}

//调用代码

System.Reflection.Assembly ass = Assembly.LoadFrom(Server.MapPath("bin/swordyang.dll")); //加载DLL
            System.Type t = ass.GetType("cn.SwordYang.TextClass");//获得类型
            object o = System.Activator.CreateInstance(t);//创建实例

            System.Reflection.MethodInfo mi = t.GetMethod("RunJs");//获得方法

            mi.Invoke(o, new object[] { this.Page,"alert('测试反射机制')"});//调用方法

反射机制对应设计模式中的策略模式。

http://blog.sina.com.cn/s/blog_3e6cb7680100lg1h.html

C#反射的入门学习首先要明白C#反射提供了封装程序集、模块和类型的对象等等。那么这样可以使用反射动态创建类型的实例，将类型绑定到现有对象，或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用了属性，可以利用反射对它们进行访问。

一个最简单的C#反射实例，首先编写类库如下：

using System;
using System.Collections.Generic;
using System.Text;

namespace ReflectionTest
{
    public class WriteTest
    {
        //public method with parametors
        public void WriteString(string s, int i)
        {
            Console.WriteLine("WriteString:" s i.ToString());
        }

        //static method with only one parametor
        public static void StaticWriteString(string s)
        {
            Console.WriteLine("StaticWriteString:" s);
        }

        //static method with no parametor
        public static void NoneParaWriteString()
        {
            Console.WriteLine("NoParaWriteString");
        }
    }
}

使用命令行编译csc /t：library ReflectTest.cs命令进行编译，生成ReflectTest.dll库文件。

然后进行下列程序的编写：

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace ReflectionTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly ass;
            Type type;
            Object obj;
            Object any = new Object();

            // 获取程序集ass
            ass = Assembly.LoadFile(@"D:\Documents and Settings\peterming\My Documents\Visual Studio 2005\Projects\ConsoleApplication1\ReflectionDll\bin\Debug\ReflectionDll.dll");

// 获取程序集ass中的一个类型
type = ass.GetType("ReflectionTest.WriteTest");

            // 获取类型type的一个方法method
            MethodInfo method = type.GetMethod("WriteString");

            // 创建两个参数的数组
            string test = "test";
            int i = 1;
            Object[] parametors = new Object[] { test, i };

// 创建程序集ass中的type.FullName类的一个对象
obj = ass.CreateInstance(type.FullName);

// 方法method, 对象obj，参数parametors
method.Invoke(obj, parametors);

            //Parametors of indicated method
            //method.Invoke(any, parametors);//RuntimeError: class reference is wrong
            method = type.GetMethod("StaticWriteString");

//The first parametor will be ignored
method.Invoke(null, new string[] { "test" });

method.Invoke(obj, new string[] { "test" });

//indicates the instance will equals above line
method.Invoke(any, new string[] { "test" });

method = type.GetMethod("NoneParaWriteString");

//Sine the method NoneParaWriteString() has no parametors so do not indicate any parametors
method.Invoke(null, null);

            Console.ReadLine();
        }
    }
}

C#反射学习时几点注意内容：

1．指定类库文件必须使用绝对路径，不能使用相对路径（其实感觉有点不合理，不太方便）

2．19行，命名空间和类的名字必须一起指定

3．在例子1种必须实例化反射要反射的类，因为要使用的方法并不是静态方法。

4．由于这个方法有两个参数，可以用这种Object的方法指定参数也可以直接写method.Invoke(obj, new Object[] { "test", 1 });

5．在例子2种我们想用的方法是一个静态方法，这时候Invoke的时候，对于第一个参数是无视的，也就是我们写什么都不会被调用，即使我们随便new了一个any这样的Object，当然这种写法是不推荐的。但是对应在例子1种我们如果Invoke的时候用了类型不一致的实例来做为参数的话，将会导致一个运行时的错误。

6．第三个例子是一个调用无参数静态方法的例子，这时候两个参数我们都不需要指定，用null就可以了。

output:
WriteString:test1
StaticWriteString：test
StaticWriteString：test
StaticWriteString：test
NoParaWriteString

再说一个问题，如果调用的类是静态类的时候，需要注意一个问题，肯定我们会想到一个问题，静态类是不能实例化的，这时候，31行的类的实例化的方法我们就不需要了，直接使用Invoke就可以实现，否则将会出现运行时的错误，同样的道理，第一个参数将会被无视，只要我们传对了参数就可以了。

反射实现步骤总结:

1:通过动态链接库的具体位置获取程序集

Assembly ass = Assembly.LoadFile(@"D:\Documents and Settings\peterming\My Documents\Visual Studio 2005\Projects\ConsoleApplication1\ReflectionDll\bin\Debug\ReflectionDll.dll");

2：通过程序集Assembly获取需要的类的类型Type type（程序集中可能含有多个类）

System.Type type = ass.GetType("ReflectionTest.WriteTest");// 参数是该类在程序集中的完整位置（命名空间类名）

3:通过type来获取类的函数（函数的属性）

MethodInfo method = type.GetMethod("WriteString"); //参数是方法名

4:通过程序集对象初始化程序集中一个类的实例
Object obj = ass.CreateInstance(type.FullName); // 参数是该类在程序集中的位置(命名空间类名)

5:创建函数执行需要的参数数组

            // 创建两个参数的数组
            string test = "test";
            int i = 1;
            Object[] parametors = new Object[] { test, i };

6:执行该函数

method.Invoke(obj,parametors);

方法二：

string StrFileName = "d:\\1.rar"; //根据实际情况设置
string StrUrl = "http://localhost/MJGPS/Images/carIcon.rar"; //根据实际情况设置中国电子调度系统\SQLPERSONAL\SQLPERSONAL\BOOKS

// 参数为程序集名称

Assembly assembly = Assembly.Load("FileTransmit");

// 创建FileTransmitNameSpace.FileTransmitClass的对象

// FileTransmitNameSpace命名空间

// FileTransmitClass命名空间里的类
FileTransmitNameSpace.FileTransmitClass transmit = (FileTransmitNameSpace.FileTransmitClass)assembly.CreateInstance("FileTransmitNameSpace.FileTransmitClass");

// 调用对象的方法

transmit.downloadFile(StrUrl, StrFileName);

C#反射Reflection学习随笔(完结篇)_AX

开篇】
这篇帖子真的憋了好久.无处下笔啊!
搜了搜园子,已经有棵这方面的好白菜了!链接如下
http://www.cnblogs.com/whxleem/category/4641.html

以此为资料,学习了一下,但心有不甘,要不前两篇许下的承诺就没法实现了!于是有了这篇帖子.

【正文】
①什么是反射?
反射提供了封装程序集、模块和类型的对象。
您可以使用反射动态地创建类型的实例(见④ )，将类型绑定到现有对象(这个不会)，或从现有对象中获取类型(见②③ )。然后，可以调用类型的方法或访问其字段和属性。
最最简单的反射:如下

using System;
2

using System.Reflection;
3

namespace TestReflection
4

{
5

class Program
6

{
7

static void Main(string[] args)
8

{
9

//创建两个对象【object和Objetct好像没有区别啊??连提示都一样!】
10

object A = new AX();
11

Object B = new AXzhz();
12

//获取对象的类型
13

new TestObjectType().TestObjectTypeNow(A, B);
14

}
15

}
16

class AX
18

{
19

}
20

class AXzhz
22

{
23

}
24

class TestObjectType
26

{
27

//构造函数的默认修饰为private
28

internal void TestObjectTypeNow(object A, object B)
29

{
30

Type tpA = A.GetType();
31

Type tpB = B.GetType();
32

Console.WriteLine(tpA.FullName);
33

Console.WriteLine(tpB.FullName);
34

Console.ReadLine();
35

}
36

}
37

}

输出结果:
TestReflection.AX
TestReflection.AXzhz
【分析】通过对象实例(A,B),可以使用GetType()方法获取该对象属于哪个类. 非类型转化后的类,而是构造该类型的类
【应用】给个变量/对象实例,测试下它属于哪个类,顺带还给出该类所属的Assembly
【附】另外一种获取类型的方法是通过Type.GetType以及Assembly.GetType方法，如：
       Type t = Type.GetType("TestReflection.AX");
    需要注意的是，前面我们讲到了命名空间和装配件的关系，要查找一个类，必须指定它所在的装配件
Type类 :表示类型声明：类类型、接口类型、数组类型、值类型、枚举类型、类型参数、泛型类型定义，以及开放或封闭构造的泛型类型。     发晕,对泛型没研究 .

②我们获得的Type实例有什么用 ?
   ⅰ获得类名:如上面例子的FullName属性,返回TestReflection.AX
       这个也比较恶心,直接用A.ToString();返回的也是这个结果.
   ⅱ创建该类的对象. 你首先通过ⅰ来获得类名AX
       AX ax = (AX)Activator.CreateInstance(tpA);
       都知道是AX类型了,怎么不new一个???鸡肋的东西.
      上面的【附】真不知道是干嘛吃的,都知道了类TestReflection.AX,直接new一个就可以了.
    ⅲ获得对象所属类的相关信息
         通过tpA的相关属性,来得到该类的相关信息.
         其实你通过A的相关属性,也可以得到该类的相关信息.还简单省事,真不知道Type类到底是干嘛吃的.

③窥一斑而知全豹,一个对象实例泄漏的密秘(这个比较爽)
通过一个对象实例,我们可以获得包含这个对象实例的类的Assembly,进而获得整个Assembly的信息.

using System;
2

using System.Reflection;
3

namespace TestReflection
4

{
5

class Program
6

{
7

public static void Main(string[] args)
8

{
9

object A = new AX();
10

//获取对象所属的Assembly的所有类的基本信息
11

new TestObjectType().TestObjectTypeNow(A);
12

}
13

}
14

class AX
16

{
17

internal int kkkkkkkk = 0;
18

public int ooooooooo;
19

private int property;
20

public int Property
22

{
23

get { return property; }
24

set { property = value; }
25

}
26

public void A()
27

{
28

Console.WriteLine("AX's function!~");
29

}
30

}
31

class AXzhz
33

{
34

}
35

class TestObjectType
37

{
38

//构造函数的默认修饰为private
39

internal void TestObjectTypeNow(object A)
40

{
41

Type tpA = A.GetType();
42

Assembly assembly = tpA.Assembly;
43

Type[] types = assembly.GetTypes();
44

foreach (Type type in types)
45

{
46

Console.WriteLine("【类名】"+type.FullName);
47

//获取类型的结构信息
48

ConstructorInfo[] myconstructors = type.GetConstructors();
49

Show(myconstructors);
50

//获取类型的字段信息
51

FieldInfo[] myfields = type.GetFields();
52

Show(myfields);
53

//获取方法信息
54

MethodInfo[] myMethodInfo = type.GetMethods();
55

Show(myMethodInfo);
56

//获取属性信息
57

PropertyInfo[] myproperties = type.GetProperties();
58

Show(myproperties);
59

//获取事件信息,这个项目没有事件,所以注释掉了,
60

//通过这种办法,还可以获得更多的type相关信息.
61

//EventInfo[] Myevents = type.GetEvents();
62

//Show(Myevents);
63

}
64

Console.ReadLine();
65

}
66

//显示数组的基本信息
67

public void Show(object[] os)
68

{
69

foreach (object var in os)
70

{
71

Console.WriteLine(var.ToString());
72

}
73

Console.WriteLine("----------------------------------");
74

}
75

}
76

}

【注】通过测试,发现只能获得public类型的信息 .

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

using System;
2

using System.Reflection;
3

namespace TestReflection
4

{
5

class AXzhz_sReflectionExample
6

{
7

public static void Main()
8

{
9

IName name=AbstractFactory.GetName();
10

name.ShowName();
11

}
12

}
13

public class AbstractFactory
15

{
16

public static IName GetName()
17

{
18

//s的值以后从Web.config动态获取
19

//把s赋值为:TestReflection.EnglishName,将显示英文名
20

string s = "TestReflection.ChineseName";
21

IName name = (IName)Assembly.Load("TestReflection").CreateInstance(s);
22

return name;
23

}
24

}
25

//声明一个接口,它有一个显示"名字"的功能
27

public interface IName
28

{
29

void ShowName();
30

}
31

//实现接口,显示中国名字
33

public class ChineseName : IName
34

{
35

public void ShowName()
36

{
37

Console.WriteLine("我叫AX!");
38

Console.ReadLine();
39

}
40

}
41

//实现接口,显示英国名字
43

public class EnglishName:IName
44

{
45

void IName.ShowName()
46

{
47

Console.WriteLine("My name is AXzhz!");
48

Console.ReadLine();
49

}
50

}
51

}

⑤获得整个解决方案的所有Assembly(这个有点用)
如果你不太清楚自己的解决方案中都用到了哪些Assembly,可以使用下面的方法,如果再想得到Assembly里的信息, 见③

using System;
2

using System.Reflection;
3

namespace TestReflection
5

{
6

class ShowAllAssembly
7

{
8

public static void Main()
9

{
10

//获得解决方案的所有Assembly
11

Assembly[] AX = AppDomain.CurrentDomain.GetAssemblies();
12

//遍历显示每个Assembly的名字
13

foreach (object var in AX)
14

{
15

Console.WriteLine("Assembly的名字:"+var.ToString());
16

}
17

//使用一个已知的Assembly名称,来创建一个Assembly
18

//通过CodeBase属性显示最初指定的程序集的位置
19

Console.WriteLine("最初指定的程序集TestReflection的位置:" + Assembly.Load("TestReflection").CodeBase);
20

Console.ReadLine();
21

}
22

}
23

}
24

其它的我就不想写了,有兴趣可以看看这个网址,整理的还是比较全.
http://jamedy.vcblog.net/archive/2006/06/12/353849.html