.NET基础拾遗（5）反射1

1.反射产生的背景

对无法直接添加引用的程序集中类型元素的动态获取和使用。使用场景如插件开发,vs本身的智能提示。

2.反射的基本原理

　　依托于元数据,运行时动态获取并构建程序集、模块、类型及字段等目标对象并调用目标对象（如调用方法,属性赋值）的机制。

元数据，就是描述数据的数据。在CLR中，元数据就是对一个模块定义或引用的所有东西的描述系统。

也就是代码架构，vs中选择一个类型，按f12转到定义。

3.反射的作用

1、查看和遍历类型(及其成员)的基本信息和程序集元数据(metadata)；

2、迟绑定(Late-Binding)方法和属性。3、动态创建类型实例(并可以动态调用所创建的实例的方法、字段、属性)

4 .反射的基础--运行时类型标识

• 运行时类型标识(RTTI),可以在程序执行期间判定对象类型。
• 运行时类型标识，能预先测试某个强制类型转换操作，能否成功，从而避免无效的强制类型转换异常。
• 在c#中有三个支持RTTI的关键字：is 、 as  、typeof。

• is运算符：

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

• as运算符：

  在运行期间执行类型转换且能够使得类型转换失败不抛异常，而返回一个null值。

• typeof运算符： 

   as ,is 能够测试两种类型的兼容性。但大多数情况下需要获得某个类型的具体信息就用到了typeof,它返回与具体类型相关的System.Type对象。一旦获得给定类型的Type对象，就可以通过使用该对象定义的各种属性，字段，方法来获取类型的具体信息。

4 .反射的核心类：System.Type

这个类封装了关于对象的信息，获得了类型的Type对象后，就可根据Type提供的属性和方法获取此类型的一切信息(方法、字段、属性、事件、参数、构造函数等)

获取Type对象有两种形式，一种是获取当前加载程序集中的类型(Runtime)，一种是获取没有加载的程序集的类型。

我们先考虑Runtime时的Type，一般来说有三种获取方法：

2.1使用Type类提供的静态方法GetType()

Type t = Type.GetType("System.IO.Stream");
txtOutput.Text = t.ToString();

注意到GetType方法接受字符串形式的类型名称。

2.2 使用 typeof 操作符

// 如果在页首写入了using System.IO; 也可以直接用 typeof(Stream);
Type t = typeof(System.IO.Stream);

这时的使用有点像泛型，Stream就好像一个类型参数一样，传递到typeof操作符中。

2.3 通过类型实例获得Type对象

String name = "Jimmy Zhang";
Type t = name.GetType();

使用这种方法时应当注意，尽管我们是通过变量(实例)去获取Type对象，但是Type对象不包含关于这个特定对象的信息，仍是保存对象的类型(String)的信息。

5 .反射程序集

在.Net中，程序集是进行部署、版本控制的基本单位，它包含了相关的模块和类型，只是讲述如何通过反射获取程序集信息。

在System.Reflection命名空间下有一个Assembly类型，它代表了一个程序集并包含了关于程序集的信息。

在程序中加载程序集时，我们可以使用 Assembly类型提供的静态方法LoadFrom() 和 Load()，比如：

Assembly asm = Assembly.LoadFrom("Demo.dll");

或者

Assembly asm = Assembly.Load("Demo");

当使用LoadFrom()方法时提供的是程序集的文件名，当将一个程序集添加到项目引用中以后，可以直接写“文件名.dll”。

如果想加载一个不属于当前项目的程序集，则需要给出全路径，比如：

Assembly asm = Assembly.LoadFrom(@"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\System.Web.dll");

使用Load()方法的时候，只用提供程序集名称即可，不需要后缀名。

如果想获得当前程序集，可以使用Assembly类型的静态方法 GetExecutingAssembly，它返回包含当前执行的代码的程序集(也就是当前程序集)。

Assembly as = Assembly.GetExecutingAssembly();

在获得一个Type类型实例以后，我们还可以使用该实例的Assembly属性来获得其所在的程序集：

Type t = typeof(int)
Assembly asm = t.Assembly;

一个程序集可能有多个模块(Module)组成，每个模块又可能包含很多的类型，但.Net的默认编译模式一个程序集只会包含一个模块。

    [Serializable]
    class SimpleClass
    {
        private String _MyString;
        public SimpleClass(String mystring)
        {
            _MyString = mystring;
        }

        public override string ToString()
        {
            return _MyString;
        }

        static void Main(string[] args)
        {
            Console.WriteLine("简单程序集");
            Console.Read();
        }
    }

    public class AnalyseHelper
    {
        /// <summary>
        /// 分析程序集
        /// </summary>
        public static void AnalyzeAssembly(Assembly assembly)
        {
            Console.WriteLine("程序集名字：" + assembly.FullName);
            Console.WriteLine("程序集位置：" + assembly.Location);
            Console.WriteLine("程序集是否在GAC中：" +
                        assembly.GlobalAssemblyCache.ToString());
            Console.WriteLine("包含程序集的模块名" +
                assembly.ManifestModule.Name);
            Console.WriteLine("运行程序集需要的CLR版本：" +
                assembly.ImageRuntimeVersion);
            Console.WriteLine("现在开始分析程序集中的模块");
            Module[] modules = assembly.GetModules();//assembly也可以直接获取所有类型调用.gettypes()
            foreach (Module module in modules)
            {
                AnalyzeModule(module);
            }
        }

        /// <summary>
        /// 分析模块
        /// </summary>
        public static void AnalyzeModule(Module module)
        {
            Console.WriteLine("模块名：" + module.Name);
            Console.WriteLine("模块的UUID：" + module.ModuleVersionId);
            Console.WriteLine("开始分析模块下的类型");
            Type[] types = module.GetTypes();
            foreach (Type type in types)
            {
                AnalyzeType(type);
            }
        }

        /// <summary>
        /// 分析类型
        /// </summary>
        public static void AnalyzeType(Type type)
        {
            Console.WriteLine("类型名字：" + type.Name);
            Console.WriteLine("类型的类别是：" + type.Attributes);
            if (type.BaseType != null)
                Console.WriteLine("类型的基类是：" + type.BaseType.Name);
            Console.WriteLine("类型的GUID是：" + type.GUID);
            //设置感兴趣的类型成员
            BindingFlags flags = (BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
            //分析成员
            FieldInfo[] fields = type.GetFields(flags);
            if (fields.Length > 0)
            {
                //Console.WriteLine("开始分析类型的成员");
                foreach (FieldInfo field in fields)
                {
                    // 分析成员
                }
            }
            //分析包含的方法
            // MethodInfo类派生于MethodBase抽象类，而MethodBase类继承了MemberInfo类
            MethodInfo[] methods = type.GetMethods(flags);
            if (methods.Length > 0)
            {
                //Console.WriteLine("开始分析类型的方法");
                foreach (MethodInfo method in methods)
                {
                    // 分析方法
                }
            }
            //分析属性
            PropertyInfo[] properties = type.GetProperties(flags);
            if (properties.Length > 0)
            {
                //Console.WriteLine("开始分析类型的属性");
                foreach (PropertyInfo property in properties)
                {
                    // 分析属性
                }
            }
        }

[PermissionSetAttribute(SecurityAction.Demand, Name = "FullTrust")]
    class Program
    {
        static void Main(string[] args)
        {
            //加载程序集
            Assembly assembly = Assembly.LoadFrom(@"..\..\..\SimpleAssembly\bin\Debug\SimpleAssembly.exe");
            AnalyseHelper.AnalyzeAssembly(assembly);

            // 创建一个程序集中的类型的对象
            Console.WriteLine("利用反射创建对象");
            string[] paras = { "测试一下反射效果" };
            object obj = assembly.CreateInstance(assembly.GetModules()[0].GetTypes()[0].ToString(), true, BindingFlags.CreateInstance, null, paras, null, null);
            Console.WriteLine(obj);

            Console.ReadKey();
        }
    }

上面代码按照 程序集->模块->类型 三个层次的顺序来动态分析一个程序集，当然还可以继续递归类型内部的成员，最后通过CreateInstance方法来动态创建了一个类型，这些都是反射经常被用来完成的功能，执行结果如下图所示：