深入理解.NET反射-CSDN博客

.NET反射的定义：审查元数据并收集关于它的类型信息的能力。

元数据是一种二进制信息，用以对存储在公共语言运行库可移植可执行文件 (PE) 文件或存储在内存中的程序进行描述。将您的代码编译为 PE 文件时，便会将元数据插入到该文件的一部分中。

而将代码转换为 Microsoft 中间语言 (MSIL) 并将其插入到该文件的另一部分中。在模块或程序集中定义和引用的每个类型和成员都将在元数据中进行说明。

当执行代码时，运行库将元数据加载到内存中，并引用它来发现有关代码的类、成员、继承等信息。

元数据以非特定语言的方式描述在代码中定义的每一类型和成员。元数据存储以下信息：

程序集的说明：

1. 标识（名称、版本、区域性、公钥）。

2. 导出的类型。

3. 该程序集所依赖的其他程序集。

4. 运行所需的安全权限。

类型的说明：

1. 名称、可见性、基类和实现的接口。

2. 成员（方法、字段、属性、事件、嵌套的类型）。

属性：

1. 修饰类型和成员的其他说明性元素。

System.reflection命名空间包含的几个类，允许你反射（解析）这些元数据表的代码和反射相关的命名空间（我们就是通过这几个命名空间访问反射信息）：

System.Reflection.MemberInfo

System.Reflection.EventInfo

System.Reflection.FieldInfo

System.Reflection.MethodBase

System.Reflection.ConstructorInfo

System.Reflection.MethodInfo

System.Reflection.PropertyInfo

System.Type System.Reflection.Assembly

.NET反射的作用：

1．可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。

2．应用程序需要在运行时从某个特定的程序集中载入一个特定的类型，以便实现某个任务时可以用到反射。

3．反射主要应用与类库，这些类库需要知道一个类型的定义，以便提供更多的功能。

应用要点：

1．在.net实现工厂模式的时候好多都会用到反射。而工厂模式用的很多。

2．使用反射动态绑定需要牺牲性能。

3．有些元数据信息是不能通过反射获取的。

4．某些反射类型是专门为那些clr 开发编译器的开发使用的，所以你要意识到不是所有的反射类型都是适合每个人的。

反射单个程序集

1． Load 方法：极力推荐的一种方法，Load 方法带有一个程序集标志并载入它，Load 将引起CLR把策略应用到程序集上。

先后在全局程序集缓冲区，应用程序基目录和私有路径下面查找该程序集，如果找不到该程序集系统抛出异常。

2． LoadFrom 方法：传递一个程序集文件的路径名（包括扩展名），CLR会载入您指定的这个程序集，传递的这个参数不能包含任何关于版本号的信息，区域性，和公钥信息，如果在指定路径找不到程序集抛出异常。

3． LoadWithPartialName：永远不要使用这个方法，因为应用程序不能确定再在载入的程序集的版本。该方法的唯一用途是帮助那些在.Net框架的测试环节使用.net 框架提供的某种行为的客户，这个方法将最终被抛弃不用。

反射的层次模型

.NET反射的概述：

应用程序结构分为应用程序域—程序集—模块—类型—成员几个层次，公共语言运行库加载器管理应用程序域。

这些域在拥有相同应用程序范围的对象周围形成了确定边界。

这种管理包括将每个程序集加载到相应的应用程序域以及控制每个程序集中类型层次结构的内存布局。

程序集包含模块，而模块包含类型，类型又包含成员，反射则提供了封装程序集、模块和类型的对象。

我们可以使用反射动态地创建类型的实例，将类型绑定到现有对象或从现有对象中获取类型，然后调用类型的方法或访问其字段和属性。反射通常具有以下用途：

（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了解参数的名称、数据类型、是输入参数还是输出参数，以及参数在方法签名中的位置等。

System.Reflection.Emit命名空间的类提供了一种特殊形式的反射，可以在运行时构造类型。

反射也可用于创建称为类型浏览器的应用程序，使用户能够选择类型，然后查看有关选定类型的信息。

此外，Jscript等语言编译器使用反射来构造符号表。System.Runtime.Serialization命名空间中的类使用反射来访问数据并确定要永久保存的字段，System.Runtime.Remoting命名空间中的类通过序列化来间接地使用反射。

反射的性能：

使用反射来调用类型或者触发方法，或者访问一个字段或者属性时clr 需要做更多的工作：校验参数，检查权限等等，所以速度是非常慢的。

所以尽量不要使用反射进行编程，对于打算编写一个动态构造类型（晚绑定）的应用程序，可以采取以下的几种方式进行代替：

1、通过类的继承关系。让该类型从一个编译时可知的基础类型派生出来，在运行时生成该类型的一个实例，将对其的引用放到其基础类型的一个变量中，然后调用该基础类型的虚方法。

2、通过接口实现。在运行时，构建该类型的一个实例，将对其的引用放到其接口类型的一个变量中，然后调用该接口定义的虚方法。

3、通过委托实现。让该类型实现一个方法，其名称和原型都与一个在编译时就已知的委托相符。

在运行时先构造该类型的实例，然后在用该方法的对象及名称构造出该委托的实例，接着通过委托调用你想要的方法。这个方法相对与前面两个方法所作的工作要多一些，效率更低一些。

提高反射的性能：反射的性能损失主要来源于比较类型、遍历成员、调用成员三种情形，其中比较类型耗时最小。

调用成员耗时最多，所以尽量减少采用成员动态调用等反射方式可以提高应用程序性能。除此之外，采取后期绑定、避免将反射方法放到循环内产生放大效应等办法均可提升反射性能。

示例如下：这是一个Calculator.dll

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

namespace Calculator
{
    public interface Iwel
    {
        string Print();
    }
    public class Arithmetic:Iwel
    {
        /// <summary>
        /// 实现接口
        /// </summary>
        /// <returns></returns>
        public string Print()
        {
            return "欢迎使用接口";
        }

        /// <summary>
        /// 没带参数的构造函数
        /// </summary>
        public Arithmetic()
        { 
            
        }

        /// <summary>
        /// 带参数构造函数
        /// </summary>
        /// <param name="num1"></param>
        /// <param name="num2"></param>
        public Arithmetic(int num1,int num2)
        {
            _num1 = num1;
            _num2 = num2;
        }

        private int _num1;
        public int Num1
        {
            get 
            {
                return _num1;
            }
            set 
            {
                _num1 = value;
            }
        }

        private int _num2;
        public int Num2
        {
            get
            {
                return _num2;
            }
            set
            {
                _num2 = value;
            }
        }

        public string Add(int num1,int num2)
        {
            Console.WriteLine("{0}+{1}={2}",num1,num2,num1+num2);
            return "Add(int num1,int num2)方法是一个共有的带参数的方法";
        }

        private string Add()
        {
            return "Add()是一个私有的不传参数的方法";
        }

        private void Subtration(int num1, int num2)
        { 
            Console.WriteLine("{0}-{1}={2} +Subtration(int num1, int num2)是一个私有带参数的方法",num1,num2,num1-num2);             
        }

        public static void Multiplication(int num1,int num2)
        {
            Console.WriteLine("{0}+{1}={2} Multiplication(int num1,int num2) 是一个共有的带参数的静态方法",num1,num2,num1*num2);
        }

        private static void Multiplication()
        {
            Console.WriteLine("Multiplication()是一个共有不带参数的静态方法");
        }
    }
}

下面是通过反射检查和调用Calculator.dll中的的方法：

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

namespace ReflectionDemo
{
    class Program
    {
        delegate void TestDelegate(int num1,int num2);
        static void Main(string[] args)
        {
            Assembly assembly = Assembly.Load("Calculator"); //加载程序集
            Console.WriteLine("得到Calculator.dll中所有的类");
            Console.WriteLine("********************************");

            foreach(Type t in assembly.GetTypes())
            {
                Console.WriteLine( "Calculator命名空间下的类：" + t.Name);
            }

            Console.WriteLine("得到Calculator.dll中所有的模块集");
            Console.WriteLine("********************************");

            foreach (Module module in assembly.GetModules())
            {
                Console.WriteLine("Calculator命名空间下的模块："+module.Name);
            }

            Console.WriteLine("********************************");
            Console.WriteLine("");

            //Type type = typeof(Calculator.Arithmetic);
            Type type = assembly.CreateInstance("Calculator.Arithmetic").GetType();;
            Console.WriteLine("具体的类的类型是" + type.Name);
            Console.WriteLine("{0}是不是public类型{1}",type,type.IsPublic);
            Console.WriteLine("{0}是不是private类型{1}",type,type.IsNotPublic);

            Console.WriteLine("********************************");
            Console.WriteLine("");
            PropertyInfo[] menberInfo = type.GetProperties();//得到类中的属性
            foreach (PropertyInfo p in menberInfo)
            {
                Console.WriteLine(type + "类的属性有" + p.Name);
            }

            Console.WriteLine("********************************");
            Console.WriteLine("");

            Type[] t1 = type.GetInterfaces();
            foreach (Type var in t1)
            {
                Console.WriteLine(var.Name + "Calculator中的接口");
            }
            Console.WriteLine("********************************");
            Console.WriteLine("");
            Console.WriteLine("方法的返回类型，方法传参的类型");

            //查找私有的方法
            MethodInfo[] method = type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic);
            foreach (MemberInfo var in method)
            {
                Console.WriteLine("私有的方法：方法名={0} 方法的信息={1}",var.Name,var);
            }

            //查找公有的方法
            MethodInfo[] methodpublic = type.GetMethods(BindingFlags.Instance | BindingFlags.Public);
            foreach (MethodInfo var in methodpublic)
            {
                Console.WriteLine("共有的方法： 方法名={0} 方法的信息={1}", var.Name, var);
            }

            //查找共有的静态方法
            MethodInfo[] methodstatic = type.GetMethods(BindingFlags.Public | BindingFlags.Static);
            foreach (MethodInfo var in methodstatic)
            {
                Console.WriteLine("公有静态方法：方法名={0} 方法的信息={1}", var.Name, var);
            }

            //查找私有的静态方法
            MethodInfo[] methdprivatestatic = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Static);
            foreach (MethodInfo var in methdprivatestatic)
            {
                Console.WriteLine("私有静态方法：方法名={0} 方法的信息={1}", var.Name, var);
            }
            Console.WriteLine("********************************");
            Console.WriteLine("这是构造方法的形式");
            ConstructorInfo[] con = type.GetConstructors(); //获得构造函数的形式
            foreach (ConstructorInfo var in con)
            {
                Console.WriteLine(var);
            }

            Console.WriteLine("********************************");
            object obj = Activator.CreateInstance(type, null); //创建了一个不带参数的实例
            //公有非静态带参数和返回参数的方法的调用
            MethodInfo men1 = type.GetMethod("Add");
            Console.WriteLine("调用{0}方法", men1);
            object[] num1 = { 5, 4 };//参数

            Console.WriteLine(men1.Invoke(obj, num1));

            Console.WriteLine("********************************");

            //私有的非静态方法的调用
            MethodInfo men2 = type.GetMethod("Add", BindingFlags.Instance | BindingFlags.NonPublic);
            Console.WriteLine(men2.Invoke(obj, null));
            Console.WriteLine("********************************");

            //公有的静态带参数的方法的调用
            MethodInfo men3 = type.GetMethod("Multiplication", BindingFlags.Public | BindingFlags.Static);
            object[] nums2 = { 5, 6 };
            men3.Invoke(null, nums2);
            Console.WriteLine("********************************");
            //私有的静态的
            MethodInfo men4 = type.GetMethod("Multiplication", BindingFlags.NonPublic | BindingFlags.Static);
            men4.Invoke(null, null);
            Console.WriteLine("********************************");

            //动态创建一个委托
            Console.WriteLine("动态声明的委托");
            TestDelegate dele = (TestDelegate)Delegate.CreateDelegate(typeof(TestDelegate), obj, "Subtration");
            dele(9, 3);


            Console.ReadKey();
        }
    }
}

执行结果：