静中有动-动态类型

在C#4.0中，最核心的特性莫过于动态类型的引入。

1、动态类型简介

    一直在强调C#是一门静态类型的语言，因为它在定义变量时要明确给出变量的类型。例如在int i=5;这样的代码中，int就是变量i的类型，如果定义变量时没有明确指定变量的类型，则这样的代码是通过不了编译的。

    在C#4.0中，微软引入了dynamic关键字来定义动态类型。当我们使用由dynamic关键字限制的变量时，编译器并不知道它的类型，该类型只能在程序运行的时候才能被确定。动态类型的定义如下面的代码所示：

    dynamic i=5;

    从上面这行代码可以看出，定义动态类型的过程非常简单，只需要把之前的int类型修改为dynamic关键字即可。

    那静态类型和动态类型到底有什么不同呢？以代码来说明：

    object obj=10;

    obj=obj+10;//编译错误

    dynamic i=10;//动态类型定义

     i=i+10;

    在以上的代码中，第一行obj为object类型，而编译器却检测出“+”运算符无法应用于object和int类型。要让代码通过编译，必须使用强制类型转换。动态类型定义就不需要转换了，动态类型定义的变量的具体类型只能在程序运行时被确定，编译器根本不知道其类型是什么，所以也就不会出现编译错误了。

2、C#为什么要引入动态类型

     2.1 可以减少强制类型转换的使用

     2.2 调用Python等动态语言

           动态类型使得C#语言调用Python这样的动态语言成为了可能。比如：

ScriptEngine engine=Python.CreateEngine();
Console.WriteLine("调用Python语言的print函数输出：");
engine.Execute("print 'Hello world'");
Console.Read();

    以上代码实现了在C#中调用Python的print函数完成消息打印的过程，但要使这段代码能够运行，还必须下载IronPython。IronPython是在.NET Framework上实现的一种动态语言。

    由于动态类型变量的具体类型只能在运行时确定，所以智能提示对于动态类型变量并不管用。开发人员在使用动态类型时，必须准确地知道类型所具有的成员，否则在程序运行时很难发现相关错误。

3、动态类型约束

    动态类型的使用需要满足一下几个约束条件：

    3.1 不能用来调用扩展方法

          不能用动态类型作为参数来调用扩展方法，例如下面的代码将导致编译错误：

           var numbers=Enumerable.Range(10,10);

           dynamic number=4;

           var error=numbers.Take(number);//编译错误

           出现这种错误的原因在于：扩展方法是在另一个文件中被定义的，若参数为动态类型，编译器将无法确定参数的具体类型，因为也就不知道该导入哪个源文件了。我们可以通过两个方法来解决这个问题：

           第一种是将动态类型强制转换为正确的类型：var right1=numbers.Take((int)number);

           第二种是使用静态方法来调用扩展方法：var right2=Enumerable.Take(numbers,number);

           这两种方法虽然都可能，但还是不推荐在调用扩展方法时使用动态类型。

    3.2 委托与动态类型间不能做隐式转换

          不能将Lambda表达式定义为动态类型，因为他们之间不存在隐式转换，如下面的代码就会出现编译错误：

          dynamic lambdarestrict=x=>x+1;//编译时错误

          如果硬要把Lambda表达式定义为动态类型，就需要明确指定委托的类型，具体的解决方案如下：

          dynamic rightLambda=（Func<int,int>）(x=>x+1);

    3.3 不能调用构造函数和静态方法

          dynamic s=new dynamic();//编译错误   因为此时编译器无法指定具体的类型。

    3.4 类型声明和泛型类型参数

          不能将dynamic关键字用来基类声明，也不能将dynamic用于类型参数的约束，或作为类型所实现的接口的一部分。具体的实例代码如下：

class DynamicBaseType:dynamic //基类不能为dynamic类型
{
}

class DynamicTypeConstrain<T> where T:dynamic //dynamic类型不能用作类型参数
{
}

class DynamicInterface :IEnumerable<dynamic>//dynamic不能作为所实现接口的一部分
{
}

4、实现自己的动态行为

    引入静态类型后，我们便可为类型动态地添加属性和方法，从而实现我们自己的动态行为。具体来说，.NET中支持3种实现动态行为的方式：

    （1）使用ExpandoObject;

    （2）使用DynamicObject;

    （3）实现IDynamicMetaObjectProvider接口

    4.1 使用ExpandoObject来实现动态行为

         ExpandoObject是实现动态行为的最简单的方式，其实现代码如下：

         

using System;
using System.Dynamic;

namespace 动态类型
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic expand = new ExpandoObject();
            //动态绑定成员
            expand.Name = "Helius";
            expand.Age = 24;
            expand.Addmethod = (Func<int, int>) (x => x + 1);
            //调用类型成员
            Console.WriteLine($"enpand类型的姓名为:{expand.Name},年龄为:{expand.Age}");
            Console.WriteLine($"调用expand类型的动态帮东方法:{expand.Addmethod(5)}");
            Console.ReadKey();
        }
    }
}

    以上代码通过使用ExpandoObject类，动态地为expand动态类型添加了属性和函数，并且expand类型也可以成功地被调用。

    4.2 使用DynamicObject来实现动态行为

         除了使用ExpandoObject，我们还可以通过重写DynamicObject来实现动态行为，具体的实现代码如下：

          

using System;
using System.Dynamic;

namespace 动态类型
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic dynamicobj=new DynamicType();
            dynamicobj.CallMethod();
            dynamicobj.Name = "Helius";
            dynamicobj.Age = 24;
            Console.ReadKey();
        }
    }


    class DynamicType:DynamicObject
    {
        //重写TryXXX方法，该方法表示对对象进行动态调用
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            Console.WriteLine($"{binder.Name}方法正在被调用");
            result = null;
            return true;
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            Console.WriteLine($"{binder.Name} 属性被设置，设置的值为{value}");
            return true;
        }
    }
}

    

    4.3 使用IDynamicMetaObjectProvider接口来实现动态行为

          由于Dynamic类型是在运行过程中动态创建对象的，所以在对该类型的每个成员进行访问时，都会首先调用GetMethodObject方法来获得动态对象，然后再通过这个动态对象来完成调用。因为为了实现IDynamicMetaObjectProvider接口，我们需要先实现一个GetMetaObject方法，用以返回DynamicMetaObject对象。

      

using System;
using System.Dynamic;
using System.Linq.Expressions;

namespace 动态类型
{
    class Program
    {
        static void Main(string[] args)
        {

            dynamic dynamicObj2=new DynamicType2();
            dynamicObj2.Call();
            Console.ReadKey();
        }
    }


    class DynamicType:DynamicObject
    {
        //重写TryXXX方法，该方法表示对对象进行动态调用
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            Console.WriteLine($"{binder.Name}方法正在被调用");
            result = null;
            return true;
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            Console.WriteLine($"{binder.Name} 属性被设置，设置的值为{value}");
            return true;
        }
    }


    internal class DynamicType2 : IDynamicMetaObjectProvider
    {
        public DynamicMetaObject GetMetaObject(Expression parameter)
        {
            Console.WriteLine("开始获得元数据......");
            return new Metadynamic(parameter, this);
        }
    }

    internal class Metadynamic : DynamicMetaObject
    {
        internal Metadynamic(Expression expression, DynamicType2 value):base(expression,BindingRestrictions.Empty,value)
        {
        }

        public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
        {
            //获得真正的对象
            DynamicType2 target = (DynamicType2) base.Value;
            Expression self = Expression.Convert(base.Expression, typeof (DynamicType2));
            var restrictions = BindingRestrictions.GetInstanceRestriction(self, target);
            //输出绑定方法名
            Console.WriteLine($"{binder.Name} 方法被调用了");
            return new DynamicMetaObject(self,restrictions);
        }
    }
}

    结果为：