C#反射学习总结

详解C#中的反射

反射（Reflection）

两个现实中的例子：
1、B超：大家体检的时候大概都做过B超吧，B超可以透过肚皮探测到你内脏的生理情况。这是如何做到

的呢？B超是B型超声波，它可以透过肚皮通过向你体内发射B型超声波，当超声波遇到内脏壁的时候就会

产生一定的“回音”反射，然后把“回音”进行处理就可以显示出内脏的情况了（我不是医生也不是声

学专家，不知说得是否准确^_^）。
2、地球内部结构：地球的内部结构大体可以分为三层：地壳、地幔和地核。地壳是固体，地核是液体，

地幔则是半液半固的结构（中学地理的内容，大家还记得吧？）。如何在地球表面不用深入地球内部就

知道其内部的构造呢？对，向地球发射“地震波”，“地震波”分两种一种是“横波”，另一种是“纵

波”。“横波”只能穿透固体，而“纵波”既可穿透固体又可以穿透液体。通过在地面对纵波和横波的

反回情况，我们就可以大体断定地球内部的构造了。

大家注意到这两个例子的共同特点，就是从一个对象的外部去了解对象内部的构造，而且都是利用了波

的反射功能。在.NET中的反射也可以实现从对象的外部来了解对象（或程序集）内部结构的功能，哪怕

你不知道这个对象（或程序集）是个什么东西，另外.NET中的反射还可以运态创建出对象并执行它其中

的方法。
反射是.NET中的重要机制，通过反射，可以在运行时获得程序或程序集中每一个类型（包括类、结构、

委托、接口和枚举等）的成员和成员的信息。有了反射，即可对每一个类型了如指掌。另外我还可以直

接创建对象，即使这个对象的类型在编译时还不知道。 
    
反射的用途：
    （1）使用Assembly定义和加载程序集，加载在程序集清单中列出模块，以及从此程序集中查找类型

并创建该类型的实例。 
    （2）使用Module了解包含模块的程序集以及模块中的类等，还可以获取在模块上定义的所有全局方

法或其他特定的非全局方法。 
    （3）使用ConstructorInfo了解构造函数的名称、参数、访问修饰符（如pulic 或private）和实现

详细信息（如abstract或virtual）等。 
    （4）使用MethodInfo了解方法的名称、返回类型、参数、访问修饰符（如pulic 或private）和实

现详细信息（如abstract或virtual）等。
    （5）使用FiedInfo了解字段的名称、访问修饰符（如public或private）和实现详细信息（如

static）等，并获取或设置字段值。
    （6）使用EventInfo了解事件的名称、事件处理程序数据类型、自定义属性、声明类型和反射类型

等，添加或移除事件处理程序。 
    （7）使用PropertyInfo了解属性的名称、数据类型、声明类型、反射类型和只读或可写状态等，获

取或设置属性值。 
    （8）使用ParameterInfo了解参数的名称、数据类型、是输入参数还是输出参数，以及参数在方法

签名中的位置等。
反射用到的命名空间：
    System.Reflection
    System.Type
    System.Reflection.Assembly
    
反射用到的主要类：
    System.Type 类－－通过这个类可以访问任何给定数据类型的信息。
    System.Reflection.Assembly类－－它可以用于访问给定程序集的信息，或者把这个程序集加载到

程序中。
    
System.Type类：
    System.Type 类对于反射起着核心的作用。但它是一个抽象的基类，Type有与每种数据类型对应的

派生类，我们使用这个派生类的对象的方法、字段、属性来查找有关该类型的所有信息。
    获取给定类型的Type引用有3种常用方式：
    使用 C# typeof 运算符。
        Type t = typeof(string);
    使用对象GetType()方法。
        string s = "grayworm";
        Type t = s.GetType(); 
    还可以调用Type类的静态方法GetType()。
        Type t = Type.GetType("System.String");
       
    上面这三类代码都是获取string类型的Type，在取出string类型的Type引用t后，我们就可以通过t

来探测string类型的结构了。 
            string n = "grayworm";
            Type t = n.GetType();
            foreach (MemberInfo mi in t.GetMembers())
            {
                Console.WriteLine("{0}/t{1}",mi.MemberType,mi.Name);
            }
    
    Type类的属性：
        Name 数据类型名
        FullName 数据类型的完全限定名(包括命名空间名)
        Namespace 定义数据类型的命名空间名
        IsAbstract 指示该类型是否是抽象类型
        IsArray   指示该类型是否是数组
        IsClass   指示该类型是否是类
        IsEnum   指示该类型是否是枚举
        IsInterface    指示该类型是否是接口
        IsPublic 指示该类型是否是公有的
        IsSealed 指示该类型是否是密封类
        IsValueType 指示该类型是否是值类型
    Type类的方法：
        GetConstructor(), GetConstructors()：返回ConstructorInfo类型，用于取得该类的构造函

数的信息
        GetEvent(), GetEvents()：返回EventInfo类型，用于取得该类的事件的信息
        GetField(), GetFields()：返回FieldInfo类型，用于取得该类的字段（成员变量）的信息
        GetInterface(), GetInterfaces()：返回InterfaceInfo类型，用于取得该类实现的接口的信

息
        GetMember(), GetMembers()：返回MemberInfo类型，用于取得该类的所有成员的信息
        GetMethod(), GetMethods()：返回MethodInfo类型，用于取得该类的方法的信息
        GetProperty(), GetProperties()：返回PropertyInfo类型，用于取得该类的属性的信息
    可以调用这些成员，其方式是调用Type的InvokeMember()方法，或者调用MethodInfo, 

PropertyInfo和其他类的Invoke()方法。 
    
    查看类中的构造方法：

        NewClassw nc = new NewClassw();
        Type t = nc.GetType();
        ConstructorInfo[] ci = t.GetConstructors();    //获取类的所有构造函数
        foreach (ConstructorInfo c in ci) //遍历每一个构造函数
        {
            ParameterInfo[] ps = c.GetParameters();    //取出每个构造函数的所有参数
            foreach (ParameterInfo pi in ps)   //遍历并打印所该构造函数的所有参数
            {
                Console.Write(pi.ParameterType.ToString()+" "+pi.Name+",");
            }
            Console.WriteLine();
        }

 
    用构造函数动态生成对象：
        Type t = typeof(NewClassw);
        Type[] pt = new Type[2];
        pt[0] = typeof(string);
        pt[1] = typeof(string);
        //根据参数类型获取构造函数 
        ConstructorInfo ci = t.GetConstructor(pt); 
        //构造Object数组，作为构造函数的输入参数 
        object[] obj = new object[2]{"grayworm","hi.baidu.com/grayworm"};   
        //调用构造函数生成对象 
        object o = ci.Invoke(obj);    
        //调用生成的对象的方法测试是否对象生成成功 
        //((NewClassw)o).show();    
    
    用Activator生成对象：
        Type t = typeof(NewClassw);
        //构造函数的参数 
        object[] obj = new object[2] { "grayworm", "hi.baidu.com/grayworm" };   
        //用Activator的CreateInstance静态方法，生成新对象 
        object o = Activator.CreateInstance(t,"grayworm","hi.baidu.com/grayworm"); 
        //((NewClassw)o).show();

    查看类中的属性：

        NewClassw nc = new NewClassw();
        Type t = nc.GetType();
        PropertyInfo[] pis = t.GetProperties();
        foreach(PropertyInfo pi in pis)
        {
            Console.WriteLine(pi.Name);
        }

  
    查看类中的public方法：

        NewClassw nc = new NewClassw();
        Type t = nc.GetType();
        MethodInfo[] mis = t.GetMethods();
        foreach (MethodInfo mi in mis)
        {
            Console.WriteLine(mi.ReturnType+" "+mi.Name);
        }

    
    查看类中的public字段

        NewClassw nc = new NewClassw();
        Type t = nc.GetType();
        FieldInfo[] fis = t.GetFields();
        foreach (FieldInfo fi in fis)
        {
            Console.WriteLine(fi.Name);
        } 

(http://hi.baidu.com/grayworm)

       
    用反射生成对象，并调用属性、方法和字段进行操作 

        NewClassw nc = new NewClassw();
        Type t = nc.GetType();
        object obj = Activator.CreateInstance(t);
        //取得ID字段 
        FieldInfo fi = t.GetField("ID");
        //给ID字段赋值 
        fi.SetValue(obj, "k001");
        //取得MyName属性 
        PropertyInfo pi1 = t.GetProperty("MyName");
        //给MyName属性赋值 
        pi1.SetValue(obj, "grayworm", null);
        PropertyInfo pi2 = t.GetProperty("MyInfo");
        pi2.SetValue(obj, "hi.baidu.com/grayworm", null);
        //取得show方法 
        MethodInfo mi = t.GetMethod("show");
        //调用show方法 
        mi.Invoke(obj, null);

       
System.Reflection.Assembly类 
     Assembly类可以获得程序集的信息，也可以动态的加载程序集，以及在程序集中查找类型信息，并

创建该类型的实例。
    使用Assembly类可以降低程序集之间的耦合，有利于软件结构的合理化。
    
    通过程序集名称返回Assembly对象
        Assembly ass = Assembly.Load("ClassLibrary831");
    通过DLL文件名称返回Assembly对象
        Assembly ass = Assembly.LoadFrom("ClassLibrary831.dll");
    通过Assembly获取程序集中类 
        Type t = ass.GetType("ClassLibrary831.NewClass");   //参数必须是类的全名
    通过Assembly获取程序集中所有的类
        Type[] t = ass.GetTypes();
       
    //通过程序集的名称反射
    Assembly ass = Assembly.Load("ClassLibrary831");
    Type t = ass.GetType("ClassLibrary831.NewClass");
    object o = Activator.CreateInstance(t, "grayworm", "http://hi.baidu.com/grayworm");
    MethodInfo mi = t.GetMethod("show");
    mi.Invoke(o, null);
   //通过DLL文件全名反射其中的所有类型
    Assembly assembly = Assembly.LoadFrom("xxx.dll的路径");
    Type[] aa = a.GetTypes();
    foreach(Type t in aa)
    {
        if(t.FullName == "a.b.c")
        {
            object o = Activator.CreateInstance(t);
        }
    }
======== 

C#反射概念以及实例详解

 
C#反射的入门学习首先要明白C#反射提供了封装程序集、模块和类型的对象等等。那么这样可以使用反

射动态创建类型的实例，将类型绑定到现有对象，或从现有对象获取类型并调用其方法或访问其字段和

属性。如果代码中使用了属性，可以利用反射对它们进行访问。


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

using System;    
   
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.Reflection;    
   
class TestApp    
{    
public static void Main()    
{    
Assembly ass;    
Type type;    
Object obj;    
   
//Used to test the static method    
Object any = new Object();    
   
//Load the dll    
//Must indicates the whole path of dll    
ass = Assembly.LoadFile(@"D:\Source Code\00.C#     
Sudy\01.Reflection\01\ReflectTest.dll");     
//Must be Namespace with class name    
type = ass.GetType("ReflectionTest.WriteTest");    
   
/**//*example1---------*/   
   
MethodInfo method = type.GetMethod("WriteString");    
   
string test = "test";    
int i = 1;    
   
Object[] parametors = new Object[]{test,i};    
   
//Since the WriteTest Class is not Static you should Create the instance of this class    
obj = ass.CreateInstance("ReflectionTest.WriteTest");    
   
method.Invoke(    
obj,//Instance object of the class need to be reflect    
parametors);//Parametors of indicated method    
   
//method.Invoke(any, parametors);//RuntimeError: class reference is wrong    
   
/**//*example2----------*/   
     
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"});//Even the class reference is wrong    
   
/**//*example3-----------*/   
   
method = type.GetMethod("NoneParaWriteString");    
   
//Sine the method NoneParaWriteString()     
   
has no parametors so do not indicate any parametors    
method.Invoke(null, null);    
   
}    
}    

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就可以了

。


再说一个问题，如果调用的类是静态类的时候，需要注意一个问题，肯定我们会想到一个问题，静态类

是不能实例化的，这时候，31行的类的实例化的方法我们就不需要了，直接使用Invoke就可以实现，否

则将会出现运行时的错误，同样的道理，第一个参数将会被无视，只要我们传对了参数就可以了。

C#反射以及C#反射实例的相关内容就向你介绍到这里，希望对你了解和学习C#反射以及C#反射实例应用

有所帮助。
========

C# 反射（Reflection）

反射指程序可以访问、检测和修改它本身状态或行为的一种能力。
程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。
您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可


以调用类型的方法或访问其字段和属性。
优缺点
优点：
1、反射提高了程序的灵活性和扩展性。
2、降低耦合性，提高自适应能力。
3、它允许程序创建和控制任何类的对象，无需提前硬编码目标类。
缺点：
1、性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机

制主要应用在对灵活性和拓展性要求很高的系统框架上，普通程序不建议使用。
2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到程序的逻辑，反射却绕过了源代码的技术

，因而会带来维护的问题，反射代码比相应的直接代码更复杂。
反射（Reflection）的用途
反射（Reflection）有下列用途：
它允许在运行时查看属性（attribute）信息。
它允许审查集合中的各种类型，以及实例化这些类型。
它允许延迟绑定的方法和属性（property）。
它允许在运行时创建新类型，然后使用这些类型执行一些任务。
查看元数据
我们已经在上面的章节中提到过，使用反射（Reflection）可以查看属性（attribute）信息。
System.Reflection 类的 MemberInfo 对象需要被初始化，用于发现与类相关的属性（attribute）。为

了做到这点，您可以定义目标类的一个对象，如下：
System.Reflection.MemberInfo info = typeof(MyClass);
下面的程序演示了这点：
using System;

[AttributeUsage(AttributeTargets.All)]
public class HelpAttribute : System.Attribute
{
   public readonly string Url;


   public string Topic  // Topic 是一个命名（named）参数
   {
      get
      {
         return topic;
      }
      set
      {


         topic = value;
      }
   }


   public HelpAttribute(string url)  // url 是一个定位（positional）参数
   {
      this.Url = url;
   }

   private string topic;
}
[HelpAttribute("Information on the class MyClass")]
class MyClass
{
}

namespace AttributeAppl
{
   class Program
   {
      static void Main(string[] args)
      {
         System.Reflection.MemberInfo info = typeof(MyClass);
         object[] attributes = info.GetCustomAttributes(true);
         for (int i = 0; i < attributes.Length; i++)
         {
            System.Console.WriteLine(attributes[i]);
         }
         Console.ReadKey();


      }
   }
}
当上面的代码被编译和执行时，它会显示附加到类 MyClass 上的自定义属性：
HelpAttribute
实例
在本实例中，我们将使用在上一章中创建的 DeBugInfo 属性，并使用反射（Reflection）来读取 


Rectangle 类中的元数据。
using System;
using System.Reflection;
namespace BugFixApplication
{
   // 一个自定义属性 BugFix 被赋给类及其成员
   [AttributeUsage(AttributeTargets.Class |
   AttributeTargets.Constructor |
   AttributeTargets.Field |
   AttributeTargets.Method |
   AttributeTargets.Property,
   AllowMultiple = true)]


   public class DeBugInfo : System.Attribute
   {
      private int bugNo;
      private string developer;
      private string lastReview;
      public string message;


      public DeBugInfo(int bg, string dev, string d)
      {
         this.bugNo = bg;
         this.developer = dev;
         this.lastReview = d;
      }


      public int BugNo
      {
         get
         {
            return bugNo;
         }
      }
      public string Developer
      {
         get
         {
            return developer;
         }
      }
      public string LastReview
      {
         get
         {
            return lastReview;
         }
      }
      public string Message
      {
         get
         {
            return message;
         }
         set
         {
            message = value;
         }
      }
   }
   [DeBugInfo(45, "Zara Ali", "12/8/2012",
Message = "Return type mismatch")]
   [DeBugInfo(49, "Nuha Ali", "10/10/2012",
Message = "Unused variable")]
   class Rectangle
   {
      // 成员变量
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      [DeBugInfo(55, "Zara Ali", "19/10/2012",
  Message = "Return type mismatch")]
      public double GetArea()
      {
         return length * width;
      }
      [DeBugInfo(56, "Zara Ali", "19/10/2012")]
      public void Display()
      {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle  
   
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle(4.5, 7.5);
         r.Display();
         Type type = typeof(Rectangle);
         // 遍历 Rectangle 类的属性
         foreach (Object attributes in type.GetCustomAttributes(false))
         {
            DeBugInfo dbi = (DeBugInfo)attributes;
            if (null != dbi)
            {
               Console.WriteLine("Bug no: {0}", dbi.BugNo);
               Console.WriteLine("Developer: {0}", dbi.Developer);
               Console.WriteLine("Last Reviewed: {0}",
dbi.LastReview);
               Console.WriteLine("Remarks: {0}", dbi.Message);
            }
         }
         
         // 遍历方法属性
         foreach (MethodInfo m in type.GetMethods())
         {
            foreach (Attribute a in m.GetCustomAttributes(true))
            {
               DeBugInfo dbi = (DeBugInfo)a;
               if (null != dbi)
               {
                  Console.WriteLine("Bug no: {0}, for Method: {1}",
dbi.BugNo, m.Name);
                  Console.WriteLine("Developer: {0}", dbi.Developer);
                  Console.WriteLine("Last Reviewed: {0}",
dbi.LastReview);
                  Console.WriteLine("Remarks: {0}", dbi.Message);
               }
            }
         }
         Console.ReadLine();
      }
   }
}
当上面的代码被编译和执行时，它会产生下列结果：
Length: 4.5
Width: 7.5
Area: 33.75
Bug No: 49
Developer: Nuha Ali
Last Reviewed: 10/10/2012
Remarks: Unused variable
Bug No: 45
Developer: Zara Ali
Last Reviewed: 12/8/2012
Remarks: Return type mismatch
Bug No: 55, for Method: GetArea
Developer: Zara Ali
Last Reviewed: 19/10/2012
Remarks: Return type mismatch
Bug No: 56, for Method: Display
Developer: Zara Ali
Last Reviewed: 19/10/2012
Remarks: 
========

 .NET简谈反射(动态调用)

http://wangqingpei557.blog.51cto.com/1009349/606400


我们继续C#基础知识的学习，这篇文章主要要讲的是我们C#程序员迈向高级C#程序员的关键性的一步。
有的朋友会说事实不是这样的，我不用反射就不能开发吗？当然可以，但是用与不用肯定是不一样的，


任何复杂抽象的分层架构或者说是复杂的设计模式均是建立在这些基础之上的，比如我们要进行模块化


、组件化开发，要严格的消除模块之间的耦合，要进行动态接口调用。这样的强大而灵活的系统开发，


必须要用反射才行；任何技术都有它存在的价值和意义，只要我们把它用在合适的位置就能发挥出惊人


的力量；能尽可能的减少我们编写的代码，更能是我们的代码便的清晰简洁；
下面我们就来学习C#中的反射的概念以及怎么使用它，用它能为我们提供什么样的好处，更重要的是能


否将我们的技术台阶提升一个高度；
1.什么叫反射
要想快速的学习一种技术，首先我们要明白这个技术是干什么的，我们需要有个大局观，需要有个总体


的认识了解，才能发挥出每个人本能的理解能力，而不是拉着你来理解我的想法，只有这样我们才能学


的更快，不知不觉我们就能形成自己一套独立的思考能力；[王清培版权所有，转载请给出署名]
自然解释：射是一种自然现象,表现为受刺激物对刺激物的逆反应；这是反射的字面解释，我们看一下计


算机编程中的反射；
编程解释：通过 System.Reflection 命名空间中的类以及 System.Type，您可以获取有关已加载的程序


集和在其中定义的类型（如类、接口和值类型）的信息。 您也可以使用反射在运行时创建类型实例，以


及调用和访问这些实例。这是来自微软官方的MSDN定义；
通过这两者的比较，我想对于我们初学者来说，反射就是通过某种事物去反射另一种事物；我们小时候


进行喜欢用镜子对着墙上照，会出现一个个小光圈，这就是很典型的反射例子，我们把它理解成计算机


里的反射就是我用某中对象去反射我无法直接获取到的东西；[王清培版权所有，转载请给出署名]
1：


这幅图我想还是比较形象的，至少在我们脑子里已经有了这么一个概念，反射、反射就是通过某种中间


设备获取到另一端的东西。
C#里面反射跟上面的概念是一样的，原理也是一样的，下面我们就用代码示例来进行讲解，我想通过本


篇文章的学习，您一定可以很透彻的理解反射的概念。
2.C#反射示例
2：


在我的解决方案里面有两个项目，Reflection是控制台应用程序，TestDll是我们所要反射的项目，在这


个项目里面我定义了一个Math类，也就是我们要反射的对象；
为了演示方便，我们需要设置一下TestDll项目的生成输出路径，也就是我们主程序的启动目录；
3：


这样设置之后，我们项目的输出文件就会在我们应用程序的启动目录中，反射也就会方便一点，为了让


初学者能少走弯路，我就费点事加上了；
按F6编译一下，会输出TestDll.dll文件到Reflection的Debug目录中，我们切换到Reflection中的Main


方法中开始进行反射操作；
using System;  
using System.Collections.Generic;  
using System.Text;  
using System.Reflection;  
using System.Diagnostics;  
 
namespace Reflection  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Assembly dll = Assembly.LoadFile(Environment.CurrentDirectory + "\


\TestDll.dll");  
            Type math = dll.GetType("TestDll.Math", true);  
            MethodInfo method = math.GetMethod("add");  
            int count = (int)method.Invoke(null, new object[] { 10, 20 });  
            Console.WriteLine("Invoke Method:" + count.ToString());  
            Console.ReadLine();  
        }  
    }  
}  
我在Math类中定义了一个静态方法add，在这里我们就可以通过反射拿到Math对象进行动态调用了；
Assembly对象就好比我们日常生活中的镜子，我用这个镜子去照一下外部的DLL文件，那个文件里面的所


有数据就可以反射给我了，我在通过托管对象进行一系列的获取调用了；具体的对象读者可以上网搜搜


，大牛们讲解的比我详细，我只是做个入门介绍而已
总结：是不是用反射很神奇，我感觉反射真的很强大，这篇文章只是反射的一个简单的应用，后面我会


讲解利用反射进行高配置的应用系统开发；


http://wangqingpei557.blog.51cto.com/1009349/606400
========

c#反射调用方法示例

获取方法的相关信息的两种形式
反射是一种允许用户获得类信息的C#功能，Type对象映射它代表的底层对象；
在.Net 中， 一旦获得了Type对象，就可以使用GetMethods()方法获取此类型支持的方法列表；该方法


的两种形式：
MethodInfo [] GetMethods()
MethodInfo [] GetMethods(BindingFlags bindingflas)  ：它的参数带有一些限制 BindingFlags  是


一个枚举
枚举成员 [DeclaredOnly,Instance ,Public]   枚举成员的功能使用  在编译器中使用"."符号后自己


认真观察 【相信你很快能够理解】
ParameterInfo[]  GetParameters() 方法返回一个方法的参数列表
下面用到的类 MyClass ，为了方便阅读，我把它折叠了！
复制代码 代码如下:


class MyClass
    {
        int x;
        int y;
        public MyClass(int i, int j)
        {
            this.x = i;
            this.y = j;
        }
        public int Sum()
        {
            return x + y;
        }
        public bool IsBetween(int i)
        {
            if (x < i && i < y)
            {
                return true;
            }
            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: " + x + "  y:  " + y);
        }
    }
MyClass
Main:
复制代码 代码如下:


Type t = typeof(MyClass);//获得一个表示MyClass类的Type对象
            Console.WriteLine("获取当前成员的名称" + t.Name);
            Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            Console.WriteLine("支持的方法");
            #region 第一种形式
            //MethodInfo[] mi = t.GetMethods();//显示Class类中被支持的方法
            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            //方法GetMethods() 把 MyClass 的基类 object方法都显示出来了
            //下面我们说说  GetMethods() 的另外一种形式，有限制的显示
            #endregion
            #region 第二种形式
            MethodInfo[] mi = t.GetMethods(BindingFlags.DeclaredOnly | 


BindingFlags.Instance | BindingFlags.Public);
            #endregion
            foreach (MethodInfo m in mi)
            {
                //返回后打印出MyClass类中成员的类型(方法的返回值类型)极其方法名称
                Console.Write("  " + m.ReturnType.Name + "  " + m.Name + " (");//ReturnType


获取此方法的返回类型
                ParameterInfo[] pi = m.GetParameters();//获得方法的参数
                for (int i = 0; i < pi.Length; i++)
                {
                    Console.Write(pi[i].ParameterType.Name + "   " + pi


[i].Name);//ParameterType 获取该参数的Type（类型）
                    if (i+1<pi.Length)
                    {
                        Console.Write(", ");
                    }


                }
                Console.WriteLine(")");
                Console.WriteLine();
            }        


            Console.ReadKey();
   
使用反射调用方法
上面 讨论了怎么获取一个类型所支持的方法，然而为我们获取对方法的调用做了充分的准备！
MethodInfo类中的Invoke() 方法提供了该技能！
它的一种形式：  object Invoke(object  obj,object [] paramenters)
obj 是一个对象引用，将调用它所指向的对象上的方法，对于static方法，obj必须为null。
所有需要传递给方法的参数都必须在parameters数组中指定。如果方法不需要参数，则paramenters必须


为null
基类MethodBase的 Invoke()方法返回被调用方法的返回值
请看下面的事例：
 
MyClass类Set()方法有所改变：
复制代码 代码如下:


public void Set(int a, int b)
        {
Console.WriteLine("Set(int,int)"); 
x = a;
y = b;
Show();
        }
        public void Set(double a, double b)
        {
Console.WriteLine("Set(double,double)");
x = (int)a;
y = (int)b;
Show();
        }
复制代码 代码如下:


Type t = typeof(MyClass);
MyClass reflectOb = new MyClass(10, 20);
int val;
Console.WriteLine("Invoke methods in " + t.Name);//调用MyClass类的方法
Console.WriteLine();
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))
    {
        //     指定 System.String.Compare(System.String,System.String) 和 


System.String.Equals(System.Object)
        //     方法的某些重载要使用的区域、大小写和排序规则。
        //StringComparison.Ordinal   使用序号排序规则比较字符串 
        object[] obj = new object[2];
        obj[0] = 9;
        obj[1] = 18;
        m.Invoke(reflectOb, obj);
    }
    else if (m.Name.Equals("Set",StringComparison.Ordinal)&&pi[0].ParameterType==typeof


(double))
    {
        object[] obj = new object[2];
        obj[0] = 1.12;
        obj[1] = 23.4;
        m.Invoke(reflectOb, obj);
    }
    else if (m.Name.Equals("Sum",StringComparison.Ordinal))
    {
        val = (int)m.Invoke(reflectOb, null);
        Console.WriteLine("Sum is : " + val);
    }
    else if (m.Name.Equals("IsBetween", StringComparison.Ordinal))
    {
        object[] obj = new object[1];
        obj[0] = 14;
        if ((bool)m.Invoke(reflectOb, obj))
        {
Console.WriteLine("14 is between x and y"); 
        }
    }
    else if (m.Name.Equals("Show",StringComparison.Ordinal))
    {
        m.Invoke(reflectOb,null);
    }
}
========

C# 利用反射根据类名创建类的实例对象

“反射”其实就是利用程序集的元数据信息。 反射可以有很多方法，编写程序时请先导入 


System.Reflection 命名空间。


1、假设你要反射一个 DLL 中的类，并且没有引用它（即未知的类型）： 
Assembly assembly = Assembly.LoadFile("程序集路径，不能是相对路径"); // 加载程序集（EXE 或 


DLL） 
dynamic obj = assembly.CreateInstance("类的完全限定名（即包括命名空间）"); // 创建类的实例 


2、若要反射当前项目中的类（即当前项目已经引用它了）可以为：


Assembly assembly = Assembly.GetExecutingAssembly(); // 获取当前程序集 
dynamic obj = assembly.CreateInstance("类的完全限定名（即包括命名空间）"); // 创建类的实例


，返回为 object 类型，需要强制类型转换


3、也可以为：


Type type = Type.GetType("类的完全限定名"); 
dynamic obj = type.Assembly.CreateInstance(type); 


4、不同程序集的话，则要装载调用，代码如下:
System.Reflection.Assembly.Load("程序集名称（不含文件后缀名）").CreateInstance("命名空间.类


名", false);
如:
dynamic o = System.Reflection.Assembly.Load("MyDll").CreateInstance("MyNameSpace.A", 


false);


 


注意：由于要用到dynamic ，需要把target 改为4.0 ，如果编译时出现“找不到编译动态表达式所需的


一个或多个类型。是否缺少引用?”的错误，是因为缺少一个引用，在项目里引用Miscorsoft.CSharp类


库，添加后就能编译成功。


补充：
1）反射创建某个类的实例时，必须保证使用类的完全限定名（命名空间 + 类名）。Type.GetType 方法


返回 null 则意味搜索元数据中的相关信息失败（反射失败），请确保反射时使用类的完全限定名。
2）反射功能十分强大，没有什么不能实现的。若实现“跨程序集”，请使用第一种方法创建类的实例，


并反射该实例的字段、属性、方法、事件... 然后动态调用之。




    /// <summary>
    /// 反射帮助类
    /// </summary>
    public static class ReflectionHelper
    {
        /// <summary>
        /// 创建对象实例
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="fullName">命名空间.类型名</param>
        /// <param name="assemblyName">程序集</param>
        /// <returns></returns>
        public static T CreateInstance<T>(string fullName, string assemblyName)
        {
            string path = fullName + "," + assemblyName;//命名空间.类型名,程序集
            Type o = Type.GetType(path);//加载类型
            object obj = Activator.CreateInstance(o, true);//根据类型创建实例
            return (T)obj;//类型转换并返回
        }


        /// <summary>
        /// 创建对象实例
        /// </summary>
        /// <typeparam name="T">要创建对象的类型</typeparam>
        /// <param name="assemblyName">类型所在程序集名称</param>
        /// <param name="nameSpace">类型所在命名空间</param>
        /// <param name="className">类型名</param>
        /// <returns></returns>
        public static T CreateInstance<T>(string assemblyName, string nameSpace, string 


className)
        {
            try
            {
                string fullName = nameSpace + "." + className;//命名空间.类型名
                //此为第一种写法
                object ect = Assembly.Load(assemblyName).CreateInstance(fullName);//加载程


序集，创建程序集里面的 命名空间.类型名 实例
                return (T)ect;//类型转换并返回
                //下面是第二种写法
                //string path = fullName + "," + assemblyName;//命名空间.类型名,程序集
                //Type o = Type.GetType(path);//加载类型
                //object obj = Activator.CreateInstance(o, true);//根据类型创建实例
                //return (T)obj;//类型转换并返回
            }
            catch
            {
                //发生异常，返回类型的默认值
                return default(T);
            }
        }
    }
========