.net反射（原：http://www.cnblogs.com/knowledgesea/archive/2013/03/02/2935920.html）

.net反射详解

 概述反射

  • 通过反射可以提供类型信息，从而使得我们开发人员在运行时能够利用这些信息构造和使用对象。
  • 反射机制允许程序在执行过程中动态地添加各种功能。

运行时类型标识

  • 运行时类型标识(RTTI),可以在程序执行期间判定对象类型。例如使用它能够确切地知道基类引用指向了什么类型对象。
  • 运行时类型标识，能预先测试某个强制类型转换操作，能否成功，从而避免无效的强制类型转换异常。
  • 在c#中有三个支持RTTI的关键字：is 、 as  、typeof。 下面依次介绍他们

is运算符：

通过is运算符，能够判断对象类型是否为特顶类型，如果两种类型是相同类型，或者两者之间存在引用，装箱拆箱转换，则表明两种类型是兼容的。

class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            B b = new B();
            if (a is A)
            {
                Console.WriteLine("a is an A");   //这个打印，因为a 是 A 类型的对象
            }
            if (b is A)
            {
                //这个打印，因为b是B类型的对象，而B类型派生于A类型，由于b对象可以转换为A类型，因此b对象与A类型是兼容的，但是反过来就不成立，例如下面不打印
                Console.WriteLine("b is an A because it is derived from");
            }
            if (a is B)
            {
                //这个不打印
                Console.WriteLine("This won‘t display , because a not derived from B");
            }
            if (a is object)
            {
                //这个打印
                Console.WriteLine("a is an object");
            }
            Console.ReadKey();
        }
    }
    class A { }
    class B : A { }

as运算符：

在运行期间执行类型转换，并且能够使得类型转换失败不抛异常，而返回一个null值，其实as也可以看作一个is运算符的简化备选方式（看例子）。

 class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            B b = new B();
            if (a is B)
            {
                b = (B)a;   //由于a变量不是B类型，因此这里将a变量转换为B类型是无效的。
            }
            else
            {
                b = null;
            }

            if (b ==null)
            {
                //这个打印
                Console.WriteLine("The cast in b=(B)a is not allowed");
            }

            //上面使用as运算符，能够把两部合二为一。

            b = a as B;   //as类型先检查强制类型转换的有效性，如果有效，则执行强类型转换过程。这些都在这一句完成。
            if (b == null)
            {
                //这个打印
                Console.WriteLine("The cast in b=(B)a is not allowed");
            }
            Console.ReadKey();
        }
    }
    class A { }
    class B : A { }

typeof运算符： 

 as ,is 能够测试两种类型的兼容性。但大多数情况下，还需要获得某个类型的具体信息。这就用到了typeof,它可以返回与具体类型相关的System.Type对象，通过System.Type对象可以去顶此类型的特征。一旦获得给定类型的Type对象，就可以通过使用该对象定义的各种属性，字段，方法来获取类型的具体信息。Type类包含了很多成员，在接下来的反射中再详细讨论。下面简单的演示Type对象，调用它的三个属性。

  static void Main(string[] args)
        {
            Type t=typeof(StringBuilder);

            Console.WriteLine(t.FullName);  //FullName属性返回类型的全称

            if (t.IsClass)
            {
                Console.WriteLine("is a class"); //打印
            }
            if (t.IsSealed)  //是否为密封类
            {
                Console.WriteLine("is Sealed");  //打印
            }
            Console.ReadKey();

        }

反射的核心类：System.Type类

  • 许多支持反射的类都位于System.Reflection命名空间中，他们是.net  Reflection API的一部分，所以在使用的反射的程序中一般都要使用 System.Reflection的命名空间。
  • System. Type类包装了类型，因此是整个反射子系统的核心，这个类中包含了很多属性和方法，使用这些属性和方法可以在运行时得到类型的信息。
  • Type类派生于System.Reflection.MemberInfo抽象类

MemberInfo类中的只读属性

属性
描述

Type DeclaringType
获取声明该成员的类或接口的类型

MemberTypes  MemberType
获取成员的类型，这个值用于指示该成员是字段、方法、属性、事件、或构造函数

Int MetadataToken
获取与特定元数据相关的值

Module Module
获取一个代表反射类型所在模块（可执行文件）的Module对象

String  Name
成员的名称

Type  ReflectedType
反射的对象类型

请注意

  • MemberType属性的返回类型为MemberTypes，这是一个枚举，它定义了用于表示不同成员的类型值。这些值包括：MemberTypes.Constructor,   MemberTypes.Method,      MemberTypes.Field,        MemberTypes.Event,      MemberTypes.Property。因此可以通过检查MemberType属性来确定成员的类型，例如，在MemberType属性的值为MemberTypes.Method时，该成员为方法
  • MemberInfo类还包含两个与特性相关的抽象方法：
    1. GetCustomAttributes() ：获得与主调对象关联的自定义特性列表。
    2. IsDefined(): 确定是否为主调对象定义了相应的特性。
    3. GetCustomAttributesData():返回有关自定义特性的信息（特性稍后便会提到）

当然除了MemberInfo类定义的方法和属性外，Type类自己也添加了许多属性和方法：如下表（只列出一些常用的，太多了，自己可以转定义Type类看下）


Type类定义的方法

方法
功能

ConstructorInfo[]  GetConstructors()
获取指定类型的构造函数列表

EventInfo[]   GetEvents();
获取指定类型的时间列

FieldInfo[]   GetFields();
获取指定类型的字段列

Type[]   GetGenericArguments();
获取与已构造的泛型类型绑定的类型参数列表，如果指定类型的泛型类型定义，则获得类型形参。对于正早构造的类型，该列表就可能同时包含类型实参和类型形参

MemberInfo[]   GetMembers();
获取指定类型的成员列表

MethodInfo[]   GetMethods();
获取指定类型的方法列表

PropertyInfo[]   GetProperties();
获取指定类型的属性列表

下面列出Type类定义的常用的只读属性


Type类定义的属性

属性
功能

Assembly   Assembly
获取指定类型的程序集

TypeAttributes   Attributes
获取制定类型的特性

Type   BaseType
获取指定类型的直接基类型

String  FullName
获取指定类型的全名

bool   IsAbstract
如果指定类型是抽象类型，返回true

bool   IsClass
如果指定类型是类，返回true

string   Namespace
获取指定类型的命名空间

使用反射

上面的列术都是为了，这里的使用。

通过使用Type类定义的方法和属性，我们能够在运行时获得类型的各种具体信息。这是一个非常强大的功能。我们一旦得到类型信息，就可以调用其构造函数，方法，和属性。可见，反射是允许使用编译时不可用的代码的。

由于Reflection API非常多，这里不可能完整的介绍他们（这里如果完整的介绍，据说要一本书，厚书）。但是,Reflection API是按照一定逻辑设计的。因此，只要知道部分接口的使用方法，就可以举一反三的使用剩余的接口。

这里我列出四种关键的反射技术：

    1. 获取方法的信息
    2. 调用方法
    3. 构造对象
    4. 从程序集中加载类型

获取方法的相关信息

一旦有了Type对象就可以使用GetMethodInfo()方法获取此类型支持的方法列表。该方法返回一个MethodInfo 对象数组，MethodInfo对象描述了主调类型所支持的方法，他位于System.Reflection命名空间中

MethodInfo类派生于MethodBase抽象类，而MethodBase类继承了MemberInfo类。因此我们能够使用这三个类定义的属性和方法。例如，使用Name属性得到方法名称。这里有两个重要的成员：

  1. ReturnType属性  ：为Type类型的对象，能够提供方法的返回类型信息
  2. GetParameters()方法  ：返回参数列表，参数信息以数组形式保存在PatameterInfo对象中。PatameterInfo类定义了大量描述参数信息的属性和方法。这里也列出两个常用的属性 ：Name（包含参数名称信息的字符串），ParameterType（参数类型的信息）。

下面代码，我将使用反射获得类中所支持的方法，还有方法的信息。

    class MyClass
    {
        int x;
        int y;
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        public int sum()
        {
            return x + y;
        }
        public bool IsBetween(int i)
        {
            if (x < i && i < y) return true;
            else return false;
        }
        public void Set(int a, int b)
        {
            x = a;
            y = b;
        }
        public void Set(double a, double b)
        {
            x = (int)a;
            y = (int)b;
        }
        public void Show()
        {
            Console.WriteLine("x:{0},y:{1}",x,y);
        }
    }
    class ReflectDemo
    {
        static void Main(string[] args)
        {
            Type t=typeof(MyClass);   //获取描述MyClass类型的Type对象
            Console.WriteLine("Analyzing methods in "+t.Name);  //t.Name="MyClass"

            MethodInfo[] mi = t.GetMethods();  //MethodInfo对象在System.Reflection命名空间下。
            foreach (MethodInfo m in mi) //遍历mi对象数组
            {
                Console.Write(m.ReturnType.Name); //返回方法的返回类型
                Console.Write(" " + m.Name + "("); //返回方法的名称

                ParameterInfo[] pi = m.GetParameters();  //获取方法参数列表并保存在ParameterInfo对象数组中
                for (int i = 0; i < pi.Length; i++)
                {
                    Console.Write(pi[i].ParameterType.Name); //方法的参数类型名称
                    Console.Write(" "+pi[i].Name);  // 方法的参数名
                    if (i + 1 < pi.Length)
                    {
                        Console.Write(", ");
                    }
                }
                Console.Write(")");
                Console.WriteLine(); //换行
            }

            Console.ReadKey();
        }
    }

输出结果为：Analyzing methods inMyClass MyClass(int i, int j)  int sum()  bool IsBetween(int i)  void Set(int a, int b)  void Set(double a, double b)  void Show()

bool Equals(object obj)   int GetHashCode()  Type GetType()  string ToString()

注意：这里输出的除了MyClass类定义的所有方法外，也会显示object类定义的共有非静态方法。这是因为c#中的所有类型都继承于object类。另外，这些信息实在程序运行时动态获得的，并不需要预先知道MyClass类的定义

GetMethods()方法的另一种形式

这种形式可以制定各种标记，已筛选想要获取的方法。他的通用形式为：MethodInfo[] GetMethods(BindingFlags bindingAttr)

BindingFlags是一个枚举，枚举值有（很多只列出5个吧）：

  1. DeclareOnly:仅获取指定类定义的方法，而不获取所继承的方法；
  2. Instance：获取实例方法
  3. NonPublic: 获取非公有方法
  4. Public： 获取共有方法
  5. Static：获取静态方法

GetMethods(BindingFlags bindingAttr)这个方法，参数可以使用or把两个或更多标记连接在一起，实际上至少要有Instance（或Static）与Public（或NonPublic）标记。否则将不会获取任何方法。

class MyClass
    {
        int x;
        int y;
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        private int sum()
        {
            return x + y;
        }
        public bool IsBetween(int i)
        {
            if (x < i && i < y) return true;
            else return false;
        }
        public void Set(int a, int b)
        {
            x = a;
            y = b;
        }
        public void Set(double a, double b)
        {
            x = (int)a;
            y = (int)b;
        }
        public void Show()
        {
            Console.WriteLine("x:{0},y:{1}",x,y);
        }
    }
    class ReflectDemo
    {
        static void Main(string[] args)
        {
            Type t=typeof(MyClass);   //获取描述MyClass类型的Type对象
            Console.WriteLine("Analyzing methods in "+t.Name);  //t.Name="MyClass"

            MethodInfo[] mi = t.GetMethods(BindingFlags.DeclaredOnly|BindingFlags.Instance|BindingFlags.Public);  //不获取继承方法，为实例方法，为公开的
            foreach (MethodInfo m in mi) //遍历mi对象数组
            {
                Console.Write(m.ReturnType.Name); //返回方法的返回类型
                Console.Write(" " + m.Name + "("); //返回方法的名称

                ParameterInfo[] pi = m.GetParameters();  //获取方法参数列表并保存在ParameterInfo对象数组中
                for (int i = 0; i < pi.Length; i++)
                {
                    Console.Write(pi[i].ParameterType.Name); //方法的参数类型名称
                    Console.Write(" "+pi[i].Name);  // 方法的参数名
                    if (i + 1 < pi.Length)
                    {
                        Console.Write(", ");
                    }
                }
                Console.Write(")");
                Console.WriteLine(); //换行
            }

            Console.ReadKey();
        }
    }

上面例子，可以看出只显示了Myclass类显示定义的公用方法。private int sum()也不显示。

使用反射调用方法

上面我们通过反射获取到了类中的所有信息，下面我们就再使用反射调用通过反射获取到的方法。

要调用反射获取到的方法，则需要在MethodInfo实例上调用Invoke() 方法。Invoke()的使用，在下面例子中演示，说明。

下面例子是：先通过反射获取到要调用的方法，然后使用Invoke()方法，调用获取到的指定方法；

class MyClass
    {
        int x;
        int y;
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        private int sum()
        {
            return x + y;
        }
        public bool IsBetween(int i)
        {
            if (x < i && i < y) return true;
            else return false;
        }
        public void Set(int a, int b)
        {
            Console.Write("Inside set(int,int).");
            x = a;
            y = b;
            Show();
        }
        public void Set(double a, double b)
        {
            Console.Write("Inside set(double,double).");
            x = (int)a;
            y = (int)b;
            Show();
        }
        public void Show()
        {
            Console.WriteLine("x:{0},y:{1}", x, y);
        }
    }

    class InvokeMethDemo
    {
        static void Main()
        {
           Type t=typeof(MyClass);
           MyClass reflectOb = new MyClass(10, 20);
           reflectOb.Show();  //输出为： x:10, y:20
           MethodInfo[] mi = t.GetMethods();
           foreach (MethodInfo m in mi)
           {
               ParameterInfo[] pi = m.GetParameters();

               if (m.Name.Equals("Set", StringComparison.Ordinal) && pi[0].ParameterType == typeof(int))
               {
                   object[] args = new object[2];
                   args[0] = 9;
                   args[1] = 10;
                   //参数reflectOb,为一个对象引用，将调用他所指向的对象上的方法，如果为静态方法这个参数必须设置为null
                   //参数args，为调用方法的参数数组，如果不需要参数为null
                   m.Invoke(reflectOb, args);   //调用MyClass类中的参数类型为int的Set方法，输出为Inside set(int,int).x:9, y:10
               }
           }
           Console.ReadKey();
        }
    }

获取Type对象的构造函数

在这之前的阐述中，由于MyClass类型的对象是都是显式创建的，因此使用反射技术调用MyClass类中的方法是没有任何优势的，还不如以普通方式调用方便简单呢。但是，如果对象是在运行时动态创建的，反射功能的优势就会显示出来。在这种情况下，要先获取一个构造函数列表，然后调用列表中的某个构造函数，创建一个该类型的实例。通过这种机制，可以在运行时实例化任意类型的对象，而不必在声明语句中指定类型。

class MyClass
    {
        int x;
        int y;
        public MyClass(int i)
        {
            x = y + i;
        }
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        public int sum()
        {
            return x + y;
        }
    }

    class InvokeConsDemo
    {
        static void Main()
        {
            Type t = typeof(MyClass);
            int val;
            ConstructorInfo[] ci = t.GetConstructors();  //使用这个方法获取构造函数列表

            int x;
            for (x = 0; x < ci.Length; x++)
            {
                ParameterInfo[] pi = ci[x].GetParameters(); //获取当前构造函数的参数列表
                if (pi.Length == 2) break;    //如果当前构造函数有2个参数，则跳出循环
            }

            if (x == ci.Length)
            {
                return;
            }

            object[] consargs = new object[2];
            consargs[0] = 10;
            consargs[1] = 20;
            object reflectOb = ci[x].Invoke(consargs);  //实例化一个这个构造函数有两个参数的类型对象,如果参数为空，则为null

            //实例化后，调用MyClass中的方法
            MethodInfo[] mi = t.GetMethods(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance);
            foreach (MethodInfo m in mi)
            {
                if (m.Name.Equals("sum", StringComparison.Ordinal))
                {
                    val = (int)m.Invoke(reflectOb, null);  //由于实例化类型对象的时候是用的两个参数的构造函数，所以这里返回的结构为30
                    Console.WriteLine(" sum is " + val);  //输出 sum is 30
                }
            }

            Console.ReadKey();
        }
    }

从程序集获得类型

在这之前的阐述中可以看出一个类型的所有信息都能够通过反射得到，但是MyClass类型本身，我们却没有做出获取。虽然前面的阐述实例，可以动态确定MyClass类的信息，但是他们都是基于以下事实：预先知道类型名，并且在typeof语句中使用它获得Type对象。尽管这种方式可能在很多种情况下都很管用，但是要发挥反射的全部功能，我们还需要分析程序集的内容来动态确定程序的可用类型。

借助Reflection API,可以加载程序集，获取它的相关信息并创建其公共可用类型的实例。通过这种机制，程序能够搜索其环境，利用潜在功能，而无需在编译期间显式的定义他们。这是一个非常有效，且令人兴奋的概念。

为了说明如何获取程序集中的类型，我创建两个文件。第一个文件定义一组类，第二个文件则反射各个类的信息。 代码效果如下。

1.这下面代码是要编译生成MyClass.exe文件的

 class MyClass
    {
        int x;
        int y;
        public MyClass(int i)
        {
            x = y + i;
        }
        public MyClass(int i, int j)
        {
            x = i;
            y = j;
        }
        public int sum()
        {
            return x + y;
        }
    }

    class Demo
    {
        static void Main()
        {
            Console.WriteLine("hello word !");
            Console.ReadKey();
        }
    }

2.这下面的代码是获取上面生成程序集的

 class Class3
    {
        static void Main() {

            Assembly asm = Assembly.LoadFrom(@"C:\Users\lenovo\Documents\visual studio 2010\Projects\Reflection_test\ConsoleApplication1\bin\Debug\MyClass.exe");  //加载指定的程序集
            Type[] alltype = asm.GetTypes();  //获取程序集中的所有类型列表
            foreach (Type temp in alltype)
            {
                Console.WriteLine(temp.Name);  //打印出MyClass程序集中的所有类型名称 MyClass , Demo
            }
            Console.ReadKey();       

        }
    }

上面获取到了，程序集中的类型，如果想操作程序集中类型中的方法，则跟前边我们累述的方法是一个样子的。

时间： 2024-11-10 13:21:13

.net反射（原：http://www.cnblogs.com/knowledgesea/archive/2013/03/02/2935920.html）的相关文章

bat常用命令，转【http://www.cnblogs.com/yplong/archive/2013/04/02/2996550.html】

1.@它的作用是隐藏它后面这一行的命令本身(只能影响当前行).2.echo中文为"反馈"."回显"的意思.它其实是一个开关命令,就是说它只有两种状态:打开和关闭.于是就有了echo on和echo off两个命令了.直接执行echo命令将显示当前echo命令状态(off或on)执行echo off将关闭回显,它后面的所有命令都不显示命令本身,只显示执行后的结果.echo. :输出空行,即相当于输入一个回车:值得注意的是命令行中的"．"要紧跟在EC

java反射详解 （转至 http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html）

本篇文章依旧采用小例子来说明,因为我始终觉的,案例驱动是最好的,要不然只看理论的话,看了也不懂,不过建议大家在看完文章之后,在回过头去看看理论,会有更好的理解. 下面开始正文. [案例1]通过一个对象获得完整的包名和类名 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 package Reflect; /**  * 通过一个对象获得完整的包名和类名  * */ class Demo{     //other codes... } class hello{     pu

Android实现推送方式解决方案【转载地址：http://www.cnblogs.com/hanyonglu/archive/2012/03/04/2378971.html】

本文介绍在Android中实现推送方式的基础知识及相关解决方案.推送功能在手机开发中应用的场景是越来起来了,不说别的,就我们手机上的新闻客户端就时不j时的推送过来新的消息,很方便的阅读最新的新闻信息.这种推送功能是好的一面,但是也会经常看到很多推送过来的垃圾信息,这就让我们感到厌烦了,关于这个我们就不能多说什么了,毕竟很多商家要做广告.本文就是来探讨下Android中实现推送功能的一些解决方案,也希望能够起到抛砖引玉的作用.^_^ 1.推送方式基础知识:  在移动互联网时代以前的手机,如果有事情

tomcat通过conf-Catalina-localhost目录发布项目详解 摘自：http://www.cnblogs.com/iyangyuan/archive/2013/09/12/3316444.html

Tomcat发布项目的方式大致有三种,但小菜认为通过在tomcat的conf/Catalina/localhost目录下添加配置文件,来发布项目,是最佳选择. 因为这样对tomcat的入侵性最小,只需要新增一个配置文件,不需要修改原有配置:而且支持动态解析,修改完代码直接生效(修改配置除外). 但是网上关于这种方法的介绍很简单,小菜来补充一下. 1.直接在eclipse中添加一个server,添加过程中指明tomcat的路径即可. 2.在tomcat服务器的conf\Catalina\local

http://www.cnblogs.com/quanyongan/archive/2013/05/28/3103243.html

http://www.cnblogs.com/xdp-gacl/p/4242221.html http://blog.csdn.net/subuser/article/details/18988813/ http://jingyan.baidu.com/article/b87fe19e93b8905218356880.html

转：Ajax 完整教程 转载地址：http://www.cnblogs.com/Garden-blog/archive/2011/03/11/1981778.html

第 1 页 Ajax 简介 Ajax 由 HTML.JavaScript? 技术.DHTML 和 DOM 组成,这一杰出的方法可以将笨拙的 Web 界面转化成交互性的 Ajax 应用程序.本文的作者是一位 Ajax 专家,他演示了这些技术如何协同工作 -- 从总体概述到细节的讨论 -- 使高效的 Web 开发成为现实.他还揭开了 Ajax 核心概念的神秘面纱,包括 XMLHttpRequest 对象. 五年前,如果不知道 XML,您就是一只无人重视的丑小鸭.十八个月前,Ruby 成了关注的中心,

启动其他APK的Activity方法 （转至http://www.cnblogs.com/lijunamneg/archive/2013/02/26/2934060.html）

有两个app,分别叫做App1和App2.App1包含两个Activity,分别叫做App1_A和App1_B.其中App1_A是入口Activity.也就是App1_A设置intent-filter,action为<action android:name="android.intent.action.MAIN" />App2只有一个Activity,叫做App2_A.现在在App2_A中通过startActivity启动App1_A是没问题的.但是启动App1_B的时候报

spring中quartz的使用。【转http://www.cnblogs.com/kay/archive/2007/11/02/947372.html】

Quartz是一个强大的企业级任务调度框架,Spring中继承并简化了Quartz,下面就看看在Spring中怎样配置Quartz:首先我们来写一个被调度的类: package com.kay.quartz;public class QuartzJob{ public void work()    {    System.out.println("Quartz的任务调度!!!");    }} Spring的配置文件: <?xml version="1.0" 

GRUB学习笔记（转自http://www.cnblogs.com/evilzy/archive/2008/03/30/1130173.html）

grub学习笔记1 首先要了解的几个概念 1.1 启动管理器 启动管理器是存储在磁盘开始扇区中的一段程序,例如,硬盘的MBR(Master Boot Record),在系统完成启动测试后,如果系统是从MBR启动,则BIOS(Basic Input/Output System)将控制传送给MBR.然后存储在MBR中的这段程序将运行.这段程序被称为启动管理器.它的任务就是将控制传送给操作系统,完成启动过程>有许多可用的启动管理器,包括GNU GRUB (Grand Unified Boot Load