使用dynamic类型来优化反射

时间 2019-12-08

标签使用 dynamic 类型优化反射繁體版

原文原文链接

什么是dynamic类型?微软给出的官方文档中这样解释：在经过 dynamic 类型实现的操做中，该类型的做用是绕过编译时类型检查。改成在运行时解析这些操做。 dynamic 类型简化了对 COM API（例如 Office Automation API）、动态 API（例如 IronPython 库）和 HTML 文档对象模型 (DOM) 的访问。在大多数状况下，dynamic 类型与 object 类型的行为相似。可是，若是操做包含 dynamic 类型的表达式，那么不会经过编译器对该操做进行解析或类型检查。编译器将有关该操做信息打包在一块儿，以后这些信息会用于在运行时评估操做。在此过程当中，dynamic类型的变量会编译为 object 类型的变量。所以，dynamic 类型只在编译时存在，在运行时则不存在。测试

下例中生成的类型是一致的：优化

　　　　　　dynamic dyn = "Fode";
　　　　　　Object obj = "Fode";this

// Rest the mouse pointer over dyn and obj to see their
        // types at compile time.
        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());

其输出结果都是String类型，可知CLR能够正确的识别出dynamic是哪一种类型，在反编译看看其生成的IL代码：编码

    IL_0000: nop
    IL_0001: ldstr "Fode"
    IL_0006: stloc.0
    IL_0007: ldstr "Fode"
    IL_000c: stloc.1
    IL_000d: call valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey()
    IL_0012: pop
    IL_0013: ret

JIT编译器将dynamic识别为String类型，并将其推算到运算栈中(IL代码中 ldstr(将新对象引用推送到存储在元数据中的字符串文字)、(stloc.*)从评估堆栈的顶部弹出当前值，并将其存储在索引*处的本地变量列表中),不一样IL代码也不所谓，前文只是介绍dynamic这个类型关键字，只须要你知道他的类型是绕过编译器就能够，如如下操做，Object类型就会报编译的错误。可是，对于 dyn + 3，不会报告任何错误。在编译时不会检查包含 dyn 的表达式，缘由是 dyn 的类型为 dynamic。spa

            dynamic dyn = "Fode";
            Object obj = "Fode";
            dyn = dyn + 3;
            obj = obj + 3;  //这句代码编译器会报错

dynamic是Framework 4.0的新特性。dynamic的出现让C#具备了若语言的特性。编译器在编译时候再也不对该类型进行检查，编译器默认dynamic对象支持开发者想要的任何特征。好比，即便你对 GetStudent()方法返回的对象一无所知，也能够像如下执行代码的调用，编译器不会报错：code

        static void Main(string[] args)
        {
            dynamic dyn = GetStudent();

            //正确的操做
            Console.WriteLine(dyn.Age);
            Console.WriteLine(dyn.Name);
            dyn.PrintName();

            //错误的操做
            //Console.WriteLine(dyn.Birthday); //该对象没有包含该属性
            //dyn.PrintAge();  //这行代码会报错误，访问级别不够
            Console.ReadKey();
        }
        static Student GetStudent()
        {
            Student student = new Student();
            student.Age = 21;
            student.Name = "Fode";
            return student;
        }

        class Student
        {
            public String Name { get; set; }
            public Int32 Age { get; set; }

            public void PrintName()
            {
                Console.WriteLine(this.Name);
            }

            private void PrintAge()
            {
                Console.WriteLine(this.Age);
            }
        }

若是运行时dyn对象不包含指定的特性(属性、字段、方法等)，运行时会抛出一个运行时的错误 RuntimeBinderException。对象

注意：有人可能会将var关键字与dynamic进行比较。实际上，var和dynamic彻底是两回事，两个不一样的概念。var其实是编译期间抛给我门的“语法糖”,一旦被编译，编译器会自动匹配var变量的实际类型，并用实际类型来替换给变量的声明，这看上去就好像咱们在编码的时候用实际类型进行声明同样，优势也显而易见，当【赋值方】类型发生变化时，【实现方】无需改变其类型，由于var会自动去适配。而dynamic被编译后，其实是一个Object类型，只不过编译器会对dynamic类型进行特殊处理，让它在编译期间不进行任何的类型检查，而是将类型检查放到了运行期。这从VS这个IDE就能看出，在编辑窗口中，var支持【智能感知】，由于vs能推断出var类型的实际类型；而dynamic声明的变量却不支持【智能感知】，由于对其运行期的类型一无所知。对dynamic变量使用【智能感知】会提示"此操做将在运行时解析"。blog

BB了这么久，重点来了，利用好了动态类型dynamic的这个特性，能够简化C#中的反射语法，更高深的优化将在之后的博客推出。在dynamic出现以前，咱们先用基础反射获取一个类中的方法，并执行它：索引

        static void Main()
        {
            DynamicObj obj = new DynamicObj();
            var fun = obj.GetType().GetMethod(nameof(obj.CallFun));
            Int32 result = (Int32)fun.Invoke(obj, new Object[] { "Fode" });
            Console.WriteLine(result);
            Console.ReadKey();
        }    
    
       public class DynamicObj
        {
            public Int32 CallFun(String str)
            {
                return str.Length;
            }
        }

其结果没有什么好讲的，就是一个用反射调用 CallFun() 方法的例子，而用dynamic以后，代码看上去更简洁了，而且在可控制的范围内减小了一次拆箱的操做，代码以下:开发

    dynamic dyn = new DynamicObj();
    Int32 result = dyn.CallFun("Fode");
    Console.WriteLine(result);

可能咱们会对这样的简化不觉得然，毕竟代码看起来并无减小多少，可是，若是考虑到效率兼优美两个特性，那么dynamic的优点就显现出来了。对上面的代码个执行10000000次，在进行分析，以下所示：

            CodeTimer.Time("使用dynamic", 10000000, () => {  //执行里面的代码10000000次
                dynamic dyn = new DynamicObj();
                Int32 result = dyn.CallFun("Fode");
            });

            CodeTimer.Time("使用基础反射", 10000000, () => { //执行里面的代码10000000次
                DynamicObj obj = new DynamicObj();
                var fun = obj.GetType().GetMethod(nameof(obj.CallFun));
                Int32 result = (Int32)fun.Invoke(obj, new Object[] { "Fode" });
            });
            Console.ReadKey();

其运行结果以下所示：

从以上结果看出，使用dynamic使用时间为481ms，基础反射使用时间为3063ms，CPU和时间上相差了5倍多，测试器 CodeTimer 的代码随后会贴出。

总结：能够看到虽然用dynamic优化后的反射跟基础反射的相比，效率虽然在同一个数量级上。但是基础反射却没有dynamic代码简洁，所以建议:始终使用dynamic来简化反射实现(前提你知道你要是实现的类型)，在日后的随笔，将会提出用ExpressionTree和Emit技术深度优化反射。

代码下载链接: https://pan.baidu.com/s/174c9KCTvg4XpCjZFkrhTbQ