C#4.0之dynamic的使用

在上一篇有关.Net 轻量 ORM Dapper 的介绍中咱们提出了两个疑问，其中之一就是怎么让 Dapper 查询传参可变的问题，固然这里主要说是个数可变。这里咱们就介绍C#4.0的新特性之一—— dynamic 。

C#4.0经常使用新特性

C#4.0引入了不少新特性方便咱们进行开发，其中经常使用的包含如下四种。

1. 可选参数
   为方法的参数设定默认值，标识它是可选的，
   

           public static void Show(string str1="str1",string str2="str2")
           {
               Console.WriteLine(str1 + str2);
           }

   
   
   
2. 命名参数
   上面的方法能够像下面遮掩的

        Show(str2:"msg");

   运行结果：str1msg。当你的方法有多个同一类型的可选参数（optional parameters）时，命名参数(Named parameters)特别有用。若是不用命名参数，编译器会把传参赋给第一个符合类型的参数，运行结果就会是：msgstr2。
   
3. Dynamic 特性
   dynamic关键字用于声明一个动态对象，而后经过该动态对象去调用方法或读写属性。之前咱们都是在运行时经过反射，Emit，CodeDom等技术来完成。建立一个dynamic类型的对象须要使用一个特殊的构建器叫ExpandoObject。
   

               dynamic person = new System.Dynamic.ExpandoObject();
   
               person.Name = "cary";
   
               person.Age = 25;
   
               person.ShowDescription = new Func<string>(() => person.Name + person.Age);
   
    
   
               Console.WriteLine(person.Name+person.Age+person.ShowDescription());           
   
               Console.ReadLine();

   
   

C#4.0之Dynamic介绍

dynamicl 类型能够很方便的随意插入字段、属性、方法。dynamic的出现让C#具备了弱语言类型的特性。dynamic类型的变量，不是在编译时候肯定实际类型的, 而是在运行时。因此 编译器在编译的时候再也不对类型进行检查，编译期默认dynamic对象支持你想要的任何特性。也就是说诸以下面的这两行代码，在程序编译时不会报错，而是在程序运行时报错：

dynamic a = "test";
a++;

这就要求咱们在使用 dynamic 关键字时要特别当心。

在上面的例子中，细心的同窗会发现 dynamic 类型须要借助 System.Dynamic.ExpandoObject 来实现，ExpandoObject() 是另外一个重要的C#4.0特性之一，为了探讨这一特性，咱们首先来看 用dynamic加强C#泛型表达力中的一段代码：

static class Calculator {
    public static T Add<T>(T t1, T t2) {
        dynamic d1 = t1;
        dynamic d2 = t2;

        return (T)(d1 + d2);
    }
}

public static void Main(string[] args){
    int i = Calculator.Add(1, 2);
    double d = Calculator.Add(1.1, 2.2);
    string s = Calculator.Add("abc", "def");

    Console.WriteLine(i + " " + d + " " + s);

}

做者在文中指出 C#代码是为了经过动态类型来实现基于duck typing的泛型参数约束。ExpandoObject 是C#支持Duck Type的根本缘由。在Visual Studio 2010 中咱们能够看到该类的成员列表，截图以下：

所属方法都是虚方法，咱们能够重写这些虚方法。这里主要看TryInvokeMember()方法。这个方法VS2010给出了详细的描述。
简单介绍一下如何使用这个方法：假设咱们一个类OurClass它继承了DynamicObject 这个Class。OurClass中有一个方法OurMethod()。接着在OurClass 类中 重写 TryInvokeMember这个基类虚方法。以上设置完后之后只要OurClass 的OurMethod方法一旦被调用都先执行一下重写后的TryInvokeMember()方法。也许您会问这样到底有何用途？OK!请先看javascript这段代码片断：

        function tryInvokeMember(obj) {
            if (obj && typeof obj.ourMethod === "function") {
                return obj.ourMethod();
            }
            alert('未找到！');
            return null;
        }

        var ourObj1 = {};
        ourObj1.Method = function () {
            alert('111');
        };

        var ourObj2 = {};
        ourObj2.ourMethod = function () {
            alert('已经找到ourMethod而且执行');
        };

        tryInvokeMember(ourObj1);
        tryInvokeMember(ourObj2);

你们读完这段js代码后应该会明白为何我要重点讨论C#4.0中的DynamicObject了吧？真正的目的就是：在DuckType 类(鸭子) 方法（鸭子叫）执行以前，咱们要判断对象的类是不是具有鸭子叫的功能？若是不具有就不该该执行，不然程序势必会抛出异常。C#中如何实现呢？步骤以下：

1. 创建DynamicAnimal 类继承DynamicObject类，而且重写TryInvokeMember虚方法：
   

   <strong>    </strong>public class DynamicAnimal : DynamicObject
       {
           public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
           {
               bool success = base.TryInvokeMember(binder, args, out result);
   
               //若是方法不存在，请将result 这个out参数赋值为null
               if (!success) 
                   result = null;
   
               //若是这个地方返回false 将会引起异常
               return true;
           }
       }

2. 创建两个DuckType类，分别为Duck 和 Human：
   

   public class Duck : DynamicAnimal
       {
           public string Quack()
           {
               return "鸭子嘛，就Quack吧!";
           }
       }
    public class Human : DynamicAnimal
       {
           public string Talk()
           {
               return "人类是用Talk,而不是Quack";
           }
       }

3. 在Console 内 创建DuckType的调用方法：
   

   public static string DoQuack(dynamic animal)
   {
       string result = animal.Quack();
       return result ?? "...人类固然不会鸭叫...";
   }

4. Console 内 Main方法调用：
   

           static void Main(string[] args)
           {
               var duck = new Duck();
               var cow = new Human();
               Console.WriteLine("鸭子是Quack");
               Console.WriteLine(DoQuack(duck));
               Console.WriteLine("人类是talk");
               Console.WriteLine(DoQuack(cow));
               Console.ReadKey();
           }

   
   程序的执行结果以下：
   
   
   

var、object、dynamic比较

在语法上这三者的用法很相近

var a=1;
object a=1;
dynamic c=1;

以及

var a = new string[]{"1"};
object b = new string[]{"1"};
dynamic c = new string[]{"1"};

比较一下有助于记忆。

var是C# 3中引入的，其实它仅仅只是一个语法糖. var自己并非一种类型, 其它二者object和dynamic是类型。var声明的变量在赋值的那一刻，就已经决定了它是什么类型。因此若是你这样使用，就会有编译错误:

var a = 1;
a = "Test";

object之因此可以被赋值为任意类型的缘由，其实都知道，由于全部的类型都派生自object. 因此它能够赋值为任何类型:

object a = 1;
a = "Test";

dynamic是C#引入的新类型，它的特色是申明为dynamic类型的变量，不是在编译时候肯定实际类型的, 而是在运行时。因此下面的代码是可以经过编译的，可是会在运行时报错:

dynamic a = "test";
a++;

上面代码内部处理的过程是怎样的呢?首先, dynamic类型赋值为字符串"test", 运行++操做的时候，.net会去寻找当前的赋值类型string中是否支持++操做，发现不支持，出现异常。因此，若是这样修改一下，就可让代码正常运行起来。

dynamic a = "test";
a = 1;
a++;

结语

以上的探讨是从使用角度出发对 C#4.0 新特性 dynamic 进行的介绍，若要对 dynamic 有更全面的理解，能够移步微软的msdn官方文档上查看 dynamic 更专业的介绍。

传送门：

• dynamic（C# 参考）https://msdn.microsoft.com/zh-cn/library/dd264741.aspx
  
• 使用类型 dynamic（C# 编程指南） https://msdn.microsoft.com/zh-cn/library/dd264736.aspx
  

参考博客：

• http://www.cnblogs.com/weidagang2046/archive/2010/11/21/1883032.html
  
• http://www.cnblogs.com/ryanding/archive/2010/12/09/1900106.html
  
• http://www.cnblogs.com/luminji/archive/2011/02/18/1957484.html
  
• http://www.cnblogs.com/JustRun1983/p/3163350.html