首页 > 代码库 > Dynamic编程

Dynamic编程

2024-07-13 18:50:29   216人阅读

  • Dynamic Binding
    • 动态绑定
      • Binding:解析Type,member,operation的过程.
      • 动态绑定将Binding从编译时延迟到运行时进行.
    • 场景
      • 编译时,程序员知道特定的function,member,operation的存在,而Compiler不知道.
1 dynamic d = GetSomeObject();2 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.
         1 public class Test 2 { 3     public dynamic Foo; 4 } 5 等同于 6 public class Test 7 { 8     [System.Runtime.CompilerServices.DynamicAttribute] 9     public object Foo;10 }
        View Code

         

    • Dynamic转换
      • 动态类型和其它类型之间,会含有隐式转换.
      • 转换成功的前提,是动态对象必须能够与目标对象类型是兼容的.
      •  
        int i = 7;dynamic d = i;long j = d; // No cast required (implicit conversion)int i = 7;dynamic d = i;short j = d; // throws RuntimeBinderException
        View Code

         

    • 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}}
          View Code

           

      • 不可(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;    }}
          View Code
      • 变种
        • 如果需要有多个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;        }    }
            View Code

             

      • 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


联系
我们