C#反射详解

作者: 幻凌风 | 来源:发表于2017-07-28 23:58 被阅读759次

两个现实中的例子：

1、B超：大家体检的时候大概都做过B超吧，B超可以透过肚皮探测到你内脏的生理情况。这是如何做到的呢？B超是B型超声波，它可以透过肚皮通过向你体内发射B型超声波，当超声波遇到内脏壁的时候就会产生一定的“回音”反射，然后把“回音”进行处理就可以显示出内脏的情况了（我不是医生也不是声学专家，不知说得是否准确^_）。
2、地球内部结构：地球的内部结构大体可以分为三层：地壳、地幔和地核。地壳是固体，地核是液体，地幔则是半液半固的结构（中学地理的内容，大家还记得吧？）。如何在地球表面不用深入地球内部就知道其内部的构造呢？对，向地球发射“地震波”，“地震波”分两种一种是“横波”，另一种是“纵波”。“横波”只能穿透固体，而“纵波”既可穿透固体又可以穿透液体。通过在地面对纵波和横波的反回情况，我们就可以大体断定地球内部的构造了。

大家注意到这两个例子的共同特点，就是从一个对象的外部去了解对象内部的构造，而且都是利用了波的反射功能。在.NET中的反射也可以实现从对象的外部来了解对象（或程序集）内部结构的功能，哪怕你不知道这个对象（或程序集）是个什么东西，另外.NET中的反射还可以运态创建出对象并执行它其中的方法。

平常我们在壹个C#项目中会用到不少的程序集，程序集的是什么？说白了就是程序的集合，最常见的.exe文件和.dll文件都是程序集。平常我们安装完成壹个软件后会发现根目录下面会有好多的dll文件，但是exe却不多，壹般壹个软件中exe文件也就那么几个！其中exe文件是可执行文件，而dll文件不可执行，它主要是扩展应用程序功能的！二者的区别主要是exe文件当中有Main函数，而dll文件则没有Main函数，也即没有程序的入口文件，所以dll文件不可执行。

对于dll文件的使用，我们在解决方案中，使用最多的可能就是新建一个项目，然后项目类型选择类库而已，然后在需要使用该类库（项目）的项目中引入该类库，导入命名空间，再使用该命名空间下的类和方法来增加主程序的功能。但是有些情况下，我们是没有办法在打开项目并查看源代码后，根据类库说明来使用dll文件的！这个时候就用到今天要说的是反射。

反射是.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.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()方法。

下面我们在壹个解决方案中新建了两个项目，其中HelloReflection是我们的主要项目，Common是壹个类库项目！我们的目的就是在不引入Common类库的前提下，在HelloReflection项目中使用Common中的数据。

01解决方案下的两个不同类型的项目.png

在Common类库中我们新建了三个类，分别是Person、Student和Teacher类

Common.Person类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace Common
{
    public class Person
    {
        public Person(int age ,string name)
        {
            this.Age = age;
            this.Name = name;
        }
        public int Age { get; set; }
        public string Name { get; set; }
        public void SayHello()
        {
            Console.WriteLine("我是Person类中的函数");
        }
        public void Write()
        {
            File.WriteAllText("Person.txt", "张三李四王五赵六田七");
        }
    }
}

Common.Student类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Common
{
    internal class Student : Person
    {
        public Student(int age, string name) : base(age, name)
        {
        }
    }
}

Common.Teacher类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Common
{
   abstract  class Teacher
    {
    }
}

要在HelloReflection项目中使用Common程序集，首先需要导入命名空间，并加载程序集文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//反射 Assembly需要的命名空间
using System.Reflection;
using System.IO;

namespace HelloReflection
{
    class Program
    {
        static void Main(string[] args)
        {
            string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,"Common.dll");
            //首先加载程序集文件
            Assembly ass = Assembly.LoadFile(path);
            Console.WriteLine("加载程序集成功");
        }
    }
}

Comon程序集文件加载进来后，要使用Common类库中的数据，首先需要获得程序集中的数据类型

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//反射  Assembly
using System.Reflection;
using System.IO;

namespace HelloReflection
{
    class Program
    {
        static void Main(string[] args)
        {
            string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,"Common.dll");
            //首先加载程序集文件
            Assembly ass = Assembly.LoadFile(path);
            Console.WriteLine("加载程序集成功");

            //获得程序集中定义的所有类型，包括公开的和不公开的
            Type[] types = ass.GetTypes();
            //获得程序集中定义的公共类型
            //Type[] types = ass.GetExportedTypes();
            foreach (Type t in types)
            {
                Console.WriteLine(t.Name);
                Console.WriteLine(t.FullName);
                Console.WriteLine(t.Namespace);
            }
            //获得程序集中指定的类型
            Type type = ass.GetType("Common.Person");
            Console.WriteLine(type.Name);
            //Console.WriteLine("----------");
        }
    }
}

注意，使用GetTypes()方法获取的是程序集中所有的类型，包括公开的和不公开的，本例中可以获得Person类、Student类和Teacher类。
但是使用GetExportedTypes()则只能获得程序集中公共的类型（即使用public修饰的Person类，而使用internal修饰的Student类和默认internal的Teacher类是无法获得的）

获得程序集中的数据类型后，即可以使用这些类型创建类的实例！因为我们无法获得具体的类型，所以在反射中只能动态创建类的实例。

有两种方式，壹种是使用程序集对象.CreateInstance()方法创建，另壹种是使用Activator.CreateInstance()方法创建，二者返回的都是Object类型的对象。区别是使用程序集.CreateInstance()方法调用系统激活器创建指定类型的实例，只能使用默认的无参构造函数；而如果我们在类库中给指定类自定义了的有参数的构造函数，则需要使用Activator.CreateInstance()来动态创建实例。

//从程序集中查找指定类型，然后使用系统激活器创建它的实例（实际上调用类型的默认无参构造函数）
object obj = ass.CreateInstance("Common.Person");
Console.WriteLine(obj.GetType());

//使用Activator动态创建带有自定义构造函数的类型的实例
object obj = Activator.CreateInstance(type, 18, "张三");
Console.WriteLine(obj.GetType());

创建对象成功后，即可使用对象中的属性、方法、字段、构造函数和事件等

获得数据源中的属性数组

PropertyInfo[] pros = obj.GetType().GetProperties();
foreach (PropertyInfo p in pros)
  {
      Console.WriteLine(p.Name);
  }

获得数据源中的方法

MethodInfo[] mds = obj.GetType().GetMethods();
foreach (MethodInfo m in mds)
 {
      Console.WriteLine(m.Name);
 }
 MethodInfo mdi = obj.GetType().GetMethod("SayHello");
mdi.Invoke(obj, null);

使用反射获得程序集中的方法的时候，不仅可以获得当前类中的方法，也可以获得父类中的方法。

获得数据源中的字段

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

IsAssignableFrom()函数的使用

Type typePerson = ass.GetType("Common.Person");
Type typeStudent = ass.GetType("Common.Student");
//IsAssignableFrom()函数，判断typeStudent是否可以赋值给typePerson类
bool b = typePerson.IsAssignableFrom(typeStudent);
Console.WriteLine(b);

IsInstanceOfType()函数的使用

Type typePerson = ass.GetType("Common.Person");
Object ob = Activator.CreateInstance(typePerson, 20, "小明");
//IsInstanceOfType()函数，判断指定对象是否是当前类的实例
bool b2 = typePerson.IsInstanceOfType(ob);
Console.WriteLine(b2);

IsSubclassOf()函数的使用

Type typePerson = ass.GetType("Common.Person");
Type typeStudent = ass.GetType("Common.Student");
//判断指定类是否是当前类的子类
bool b3 = typeStudent.IsSubclassOf(typePerson);
Console.WriteLine(b3);

IsAbstract属性

Type typeTeacher = ass.GetType("Common.Teacher");
bool b4 = typeTeacher.IsAbstract;
Console.WriteLine(b4);

HelloReflection项目代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//反射  Assembly
using System.Reflection;
using System.IO;

namespace HelloReflection
{
    class Program
    {
        static void Main(string[] args)
        {
            string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,"Common.dll");
            //首先加载程序集文件
            Assembly ass = Assembly.LoadFile(path);
            Console.WriteLine("加载程序集成功");
            #region 获得程序集中数据类型的3种方式
            //获得程序集中定义的所有类型，包括公开的和不公开的
            Type[] types = ass.GetTypes();
            //获得程序集中定义的公共类型
            //Type[] types = ass.GetExportedTypes();
            foreach (Type t in types)
            {
                Console.WriteLine(t.Name);
                Console.WriteLine(t.FullName);
                Console.WriteLine(t.Namespace);
            }
            //获得程序集中指定的类型
            Type type = ass.GetType("Common.Person");
            Console.WriteLine(type.Name);
            //Console.WriteLine("----------");
            #endregion


            //从程序集中查找指定类型，然后使用系统激活器创建它的实例（实际上调用类型的默认无参构造函数）
            //object obj = ass.CreateInstance("Common.Person");

            //使用Activator动态创建带有自定义构造函数的类型的实例
            object obj = Activator.CreateInstance(type, 18, "张三");
            
            Console.WriteLine(obj.GetType());
            //获得数据源中的属性数组
            PropertyInfo[] pros = obj.GetType().GetProperties();
            foreach (PropertyInfo p in pros)
            {
                Console.WriteLine(p.Name);
            }
            //获得数据源中的方法
            MethodInfo[] mds = obj.GetType().GetMethods();
            foreach (MethodInfo m in mds)
            {
                Console.WriteLine(m.Name);
            }
            MethodInfo mdi = obj.GetType().GetMethod("SayHello");
            mdi.Invoke(obj, null);
            //获得数据源中的字段
            FieldInfo[] fis = obj.GetType().GetFields();
            foreach (FieldInfo f in fis)
            {
                Console.WriteLine(f);
            }
            //获得数据源中的构造函数
            ConstructorInfo[] cis = obj.GetType().GetConstructors();
            foreach (ConstructorInfo c in cis)
            {
                Console.WriteLine(c);
            }

            Type typePerson = ass.GetType("Common.Person");
            Type typeStudent = ass.GetType("Common.Student");
            Type typeTeacher = ass.GetType("Common.Teacher");
            //IsAssignableFrom()函数，判断typeStudent是否可以赋值给typePerson类
            bool b1 = typePerson.IsAssignableFrom(typeStudent);
            Console.WriteLine(b1);

            Object ob = Activator.CreateInstance(typePerson, 20, "小明");
            //IsInstanceOfType()函数，判断指定对象是否是当前类的实例
            bool b2 = typePerson.IsInstanceOfType(ob);
            Console.WriteLine(b2);

            //判断指定类是否是当前类的子类
            bool b3 = typeStudent.IsSubclassOf(typePerson);
            Console.WriteLine(b3);

            //判断当前类是否是抽象类
            bool b4 = typeTeacher.IsAbstract;
            Console.WriteLine(b4);
        }
    }
}