Dynamic编程

• Dynamic Binding
• 动态绑定
  • Binding:解析Type,member,operation的过程.
  • 动态绑定将Binding从编译时延迟到运行时进行.
• 场景
• 编译时,程序员知道特定的function,member,operation的存在,而Compiler不知道.

 dynamic d = GetSomeObject();
 d.Quack();

dynamic_obj

• 期望在运行时,d类型会含有Quack().所以,编译器推迟d和Quack()的绑定到运行时.
• dynamic
  • dynamic与object关键字一样,不提供任何对象类型的信息.
  • 但是,区别在于,如果Compiler遇见dynamic,会将语句包装起来,然后在运行时进行Binding动作.
• Custom Binding
  • 发生在一个实现了IDynamicMetaObjectProvider的动态对象上.
  • 大部分动态对象都是从实现了DLR的动态语言中获得,但是也可以自定义.
  • 动态对象可以直接地控制所有对它的消息调用的处理过程.
• Language Binding
  • 发生在一个动态对象没有实现IDMOP接口时.
  • 适用于需要绕过基础类型的缺陷和在类型上先天的限制.
  • 比如,数值类型没有一个统一的接口.可以使用dynamic来对应所有的类型.
  • 它绕过了编译时类型安全的检查,但是不能绕过成员访问规则(反射可以).
  • 动态绑定会造成一定的性能损失.但是DLR有cache机制,针对同一动态语句的调用会被优化.
• RuntimeBinderException
  • 如果绑定失败,抛出该异常.
• Dynamic的运行时描述
  • Object和Dynamic有很深的相等性
    • typeof (dynamic) == typeof (object)
    • typeof (List<dynamic>) == typeof (List<object>)
    • typeof (dynamic[]) == typeof (object[])
    • Dynamic引用和Object引用一样,可以指向任何的类型(pointer除外).
  • 这样,可以在支持Dynamic的语言中使用Dynamic特性,而不支持时使用Object.

     public class Test
     {
         public dynamic Foo;
     }
     等同于
     public class Test
     {
         [System.Runtime.CompilerServices.DynamicAttribute]
         public object Foo;
     }

• Dynamic转换
  • 动态类型和其它类型之间,会含有隐式转换.
  • 转换成功的前提,是动态对象必须能够与目标对象类型是兼容的.

  • int i = ;
    dynamic d = i;
    long j = d; // No cast required (implicit conversion)
    
    int i = ;
    dynamic d = i;
    short j = d; // throws RuntimeBinderException

• Dynamic表达式
  • 试图使用一个返回结果为void的表达式的结果值时,会在运行时抛出异常.
  • dynamic list = new List<int>();
    var result = list.Add (5); // RuntimeBinderException thrown.
  • 而在此种情况下,使用var/object会造成编译时错误.
  • 设计dynamic的表达式,本身也是dynamic的.
  • dynamic x = 2;
    var y = x * 3; // Static type of y is dynamic
  • 编译器会"尽可能早地确定类型"

    • class Program
      {
      static void Foo (object x, object y) { Console.WriteLine ("oo"); }
      static void Foo (object x, string y) { Console.WriteLine ("os"); }
      static void Foo (string x, object y) { Console.WriteLine ("so"); }
      static void Foo (string x, string y) { Console.WriteLine ("ss"); }
      static void Main()
      {
      object o = "hello";
      dynamic d = "goodbye";
      Foo (o, d); // os
      }
      }

  • 不可(Dynamic)调用的Function.
    • 扩展方法(附加类型:扩展方法所定义的类)
    • 转型为接口后,调用接口的方法.
    • 被子类隐藏的父类成员.
    • 动态绑定需要两块信息:方法名,调用方法的对象.
    • 根源:以上3种情况下,都需要附加的类型.而此附加类型只在编译时可知.
• Dynamic Language Runtime.
  • 在动态/静态语言中,提供运行时服务来统一动态编程.
  • 简化了编写新的动态语言的工作.
    • 编写者不再需要emit IL.而是工作在Expression Tree级别上.
  • call-site caching
    • 在Dynamic绑定时,避免不必要的重复的成员解析的开销.
    • Call-site
      • 充当调用者和被调用者的中介.
    • 对于一个动态操作,编译器最终会将其反映为Expression Tree形式,并被一个call site管理.
    • 之后,在运行时DLR使用表达式树来进行Binding操作.,
    • 使用静态字段来存储call site,来避免每次调用时的重复创建.
  • 统合数字类型
    • static dynamic Mean (dynamic x, dynamic y)
      {
        return (x + y) / 2;
      }
      static void Main()
      {
        int x = 3, y = 5;
        Console.WriteLine (Mean (x, y));
      }
    • 这样会牺牲编译时的类型安全检查.
    • string s = Mean (3, 5); // Runtime error!而会编译通过!.
    • static T Mean<T> (T x, T y)
      {
        dynamic result = ((dynamic) x + y) / 2;
        return (T) result;
      }
    • 解决方法是引入泛型,并在运算内部,将参数显示转换为dynamic.
    • 动态绑定会造成一定的性能损失,如果根据监测结果,某种类型的调用是性能瓶颈,那么使用该特定类型来重载dynamic操作.而编译器会优先使用这些编译时就能确定类型的重载方法版本.
    • static double Mean (double x, double y)
      {
        return (x + y) / 2;
      }
• 动态成员重载解析
• 使用dynamic类型参数来调用静态已知方法,会将成员重载解析过程推迟到Runtime.
• 简化Visitor模式
  • Visitor模式的本质是在不改动寄存Class的前提下,给一个Class继承层次添加方法.
  • 该模式的静态实现方式,精巧且不直观.并且需要被访问类要"Visitor友好"即暴露Visitor方法.
  • class Person
    {
      public string FirstName { get; set; }
      public string LastName { get; set; }
      // The Friends collection may contain Customers & Employees:
      public readonly IList<Person> Friends = new Collection<Person> ();
    }
  • class Customer : Person { public decimal CreditLimit { get; set; } }
    class Employee : Person { public decimal Salary { get; set; } }
  • 需求:将Person及其子类的信息写入XML中.
  • 解决方案1
    • 在Person中定义virtual ToXMLElement().
    • 然后在两个子类中重载它,并写入子类特定属性.
    • 问题:1,这三个类可能不在你控制之下(即无法修改它们).2,这样给这3个类添加了过多的职责.
  • 解决方案2

    • class ToXElementPersonVisitor
      {
          public XElement DynamicVisit (Person p)
          {
              return Visit ((dynamic)p);
          }
      
          XElement Visit (Person p)
          {
              return new XElement ("Person",
                  new XAttribute ("Type", p.GetType().Name),
                  new XElement ("FirstName", p.FirstName),
                  new XElement ("LastName", p.LastName),
                  p.Friends.Select (f => DynamicVisit (f))
              );
          }
      
          XElement Visit (Customer c) // Specialized logic for customers
          {
              XElement xe = Visit ((Person)c); // Call "base" method
              xe.Add (new XElement ("CreditLimit", c.CreditLimit));
              return xe;
          }
      
          XElement Visit (Employee e) // Specialized logic for employees
          {
              XElement xe = Visit ((Person)e); // Call "base" method
              xe.Add (new XElement ("Salary", e.Salary));
              return xe;
          }
      }                                        

  • 变种
    • 如果需要有多个Visitor,那么可以定义一个抽象基类.
    • abstract class PersonVisitor<T>
      {
        public T DynamicVisit (Person p) { return Visit ((dynamic)p); }
        protected abstract T Visit (Person p);
        protected virtual T Visit (Customer c) { return Visit ((Person) c); }
        protected virtual T Visit (Employee e) { return Visit ((Person) e); }
      }
    • 这样,子类只需针对不同的Person类型来实现特殊的Visitor方法.

      •     class ToXElementPersonVisitor : PersonVisitor<XElement>
            {
                protected override XElement Visit(Person p)
                {
                    return new XElement("Person",
                    new XAttribute("Type", p.GetType().Name),
                    new XElement("FirstName", p.FirstName),
                    new XElement("LastName", p.LastName),
                    p.Friends.Select(f => DynamicVisit(f))
                    );
                }
                protected override XElement Visit(Customer c)
                {
                    XElement xe = base.Visit(c);
                    xe.Add(new XElement("CreditLimit", c.CreditLimit));
                    return xe;
                }
                protected override XElement Visit(Employee e)
                {
                    XElement xe = base.Visit(e);
                    xe.Add(new XElement("Salary", e.Salary));
                    return xe;
                }
            }

  • Multiple Dispatch
    • virtual方法调用
      • 基于名称和签名,编译器必须在编译时定位到一个特定的重载方法上.
      • 重载解析完全发生在编译时,所以重载方法参数的解析也发生在编译时.
      • 它被称为single dispatch.
      • animal.Walk (owner);
      • 编译器决定调用的依据是animal的类型,即接收者的类型.
      • 而对于owner参数,如果Walk方法针对其继承体系有不同的实现,那么是无视的.
    • dynamic call
      • animal.Walk ((dynamic) owner);
      • 推迟重载解析到运行时.
      • Walk的重载版本的解析,依赖于animal和owner两个对象的具体类型(运行时类型).
      • 称为Multiple Dispatch.除了接收者的类型,方法参数的类型也会参与到重载解析决策中.
  • 匿名调用泛型类型的成员
    • 静态类型一方面保证了编译时的正确性,但又可能使得一些代码难以编写.
    • 此时,除了Reflection,动态绑定也可以对应.
    • public class Foo<T> { public T Value; }
          static void Write (object obj)
          {
              if (obj is Foo<>) // Illegal
              Console.WriteLine ((Foo<>) obj).Value); // Illegal
          }
    • 不能调用unbound的泛型类型的方法.
    • 动态调用的方案1
      • static void Write (dynamic obj)
        {
          try { Console.WriteLine (obj.Value); }
          catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException) {...}
        }
      • 问题
        • 混乱和低效,在抛出异常时,不能确定是类型没有value属性还是value值为null.
        • 在以下的情况下,不能达到预期
          • FOO是一个接口.
          • Value被显示实现.
          • 实现了IFoo的类型是不可访问的.
    • 动态调用方案2
      • static void Write (dynamic obj)
        {
          object result = GetFooValue (obj);
          if (result != null) Console.WriteLine (result);
        }
        static T GetFooValue<T> (Foo<T> foo) { return foo.Value; }
        static object GetFooValue (object foo) { return null; }
      • Object参数类型的GetFooValue方法作为其它类型的回退调用.
        • 如果调用时,参数的类型不是基于Foo<T>的,会调用之.
      • 也可以不编写该重载方法,而使用catch来捕获Exception.
• 实现动态对象
• 对象可以通过实现IDMOP接口,或者继承DynamicObject来提供绑定语义.
• Dynamic对象
  • 重载TryInvokeMethod()让用户控制对动态对象的方法调用的执行.
  • 它还含有TryGet/SetMember,TryGet/SetIndex等方法来处理对应的操作.
  • 如果这些Try方法能够成功处理,那么返回true,否则返回false,然后语言Binder会查找对应的方法.如果还是找不到抛出RuntimeBinderException.
• ExpandoObject
• 用途:一个词典,以string为key.值是object.
• 该对象实现了IDictionary<string,object>接口.
• dynamic x = new ExpandoObject();
  x.FavoriteColor = ConsoleColor.Green;
  x.FavoriteNumber = 7;
  Console.WriteLine (x.FavoriteColor); // Green
  Console.WriteLine (x.FavoriteNumber); // 7
• 与动态语言交互
  • 虽然C#支持动态绑定,但是不能执行以string描述的表达式
    • string expr = "2 * 3";
      // We can't "execute" expr
    • 原因是将string转换为一个表达式需要语义和词法分析器.而它们被绑定到C#的编译器上,在运行时是不可见的.
    • 在运行时,C#只提供了一个Binder.它的职责是告诉DLR如何解析已经构建好的表达式树.
  • 可以在C#中引入IntroPython之类的DLL,然后进行动态语言的调用.
  • 类型自动地在.Net和Python之间转换,我们可以在Python中直接使用.Net中的类型.
  • // The following string could come from a file or database:
    string auditRule = "taxPaidLastYear / taxPaidThisYear > 2";
    ScriptEngine engine = Python.CreateEngine ();
    ScriptScope scope = engine.CreateScope ();
    scope.SetVariable ("taxPaidLastYear", 20000m);
    scope.SetVariable ("taxPaidThisYear", 8000m);
    ScriptSource source = engine.CreateScriptSourceFromString (
    auditRule, SourceCodeKind.Expression);
    bool auditRequired = (bool) source.Execute (scope);
    Console.WriteLine (auditRequired); // True