C#4.0 动态绑定(Dynamic Binding)(转)
时间:2011-06-11 来源:董雨
.NET 4.0引入了一个新概念,叫动态绑定。所谓绑定,就是对类型、成员和操作的解析过程。动态绑定意味着与编译器无关,而与运行时有关。
<!--[endif]-->
一、 基本概念
<!--[endif]-->C# 4.0之前的变量声明,在编译时已经决定其类型,虽然C# 3.0提供了var关键字来声明隐式类型,但用var声明的变量终究逃不过编译器的法眼。用dynamic声明变量的好处是,编译器在编译时并不知道它引用对象的确切类型,而要到运行时才知道。因此,我们可以通过动态绑定在运行时来操作一些类型的属性、方法等(如与IronPython,IronRuby,COM互操作),而这些在编译时编译器并不知情。
dynamic d = GetSomeObject();
d.Foo();
此处代码在编译时,编译器并未将Foo()方法绑定到变量d, 而是延时到运行时才绑定。我们可以通过IL DASM查看,会发现,当有动态类型时,会交给DLR去处理。
二、 静态绑定(Static Binding)VS动态绑定(Dynamic Binding)C# 4.0之前,每当声明一个变量时,都有一个具体的类型与之对应。因为编译器在编译时会进行类型检查,一旦出现类型方法匹配失败,语言错误等编译器就会报错。请看下面的两行代码:
SomeType st = ...
st.DoSomething();
当编译器编译这段代码时,最简单的情况是编译器绑定SomeType类型的DoSomething无参方法。如果失败,则查找SomeType的DoSomething可选参数版本或SomeType基类方法。如果还失败,再查找SomeType的扩展方法版本。如果再失败,编译器就会报编译错误。我们可以看出,静态绑定是编译器基于可知类型之上的绑定。
现在,我们把st变为Object类型, 如下:
Object st = ...
st.DoSomething();
编译时,我们也会得到一个编译错误,因为Object类型并没有DoSomething()方法。我们再修改代码如下:
dynamic st = ...
st.DoSomething();
dynamic就是一个难以具体描述的对象,虽然你可以使用,但它却是在运行时基于它的运行时类型的绑定。因为它不是一个编译时类型,当编译器在编译时发现有动态类型,就把绑定交给运行时来做,即DLR。
三、 自定义绑定(Custom Binding) VS 语言绑定(Language Binding)
自定义绑定发生在所有实现了System.Dynamic.IDynamicMetaObjectProvider接口的类型上。因为在C# 4.0的动态类型世界里,实现了System.Dynamic.IDynamicMetaObjectProvider接口的类型意味着对该类的实例的操作都会在运行时进行。如下面代码所示: 代码using System.Dynamic;
namespace CustomBinding
{
public class SomeType : DynamicObject
{
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
Console.WriteLine(binder.Name + " method is calling.");
result = null;
return true;
}
}
public class Program
{
static void Main()
{
dynamic d = new SomeType();
d.DoOneThing();
d.DoOtherThing();
}
}
}
<!--[endif]-->
由于DynamicObject类实现了IDynamicMetaObjectProvider接口,所以SomeType就是自定义绑定类型。从上面代码中我们可以看出,SomeType类并没有定义DoOneThing()方法与DoOtherThing()方法, 由于方法绑定是在运行时进行的,因此我们编译这段代码时就不会在编译时得到任何错误信息。
<!--[endif]-->语言绑定发生在没有实现IDynamicMetaObjectProvider接口的dynamic对象上。语言绑定是个非常有用的功能,下面的代码只是它的一个简单示例,我们可以看出,它与泛型算法有异曲同工之妙,如下面代码所示:
代码using System.Dynamic;
namespace LanguageBinding
{
public class Program
{
static void Main()
{
int x = 2, y = 6;
int result = Compute(x, y);
Console.WriteLine(result);
}
static dynamic Compute(dynamic x, dynamic y)
{
return (x + y) / 2;
}
}
}
<!--[endif]-->
四、 RuntimeBinderException
对于动态绑定,在运行时绑定失败时,会抛出一个RuntimeBinderException异常。如下面代码所示会得到一个RuntimeBinderException。
dynamic d = 5;
d.Hello();//此处抛出RuntimeBinderException异常
五、 动态转换(Dynamic Conversions)
动态(dynamic)类型与其它类型之间可以相互隐式转换。如:
int i = 5;
dynamic d = i;
int j = d; //这些赋值操作都不需要显示转换
long l = d; //运行时知道d是int类型,int类型可以隐式转换成long类型
如果转换不成功,运行时分抛出一个RuntimeBinderException异常。如下所示:
int i = 5;
dynamic d = i;
short s = d; //此处抛出一个RuntimeBinderException异常,因为int不能隐式转换成short类型
六、 动态表达式中的静态类型
一般说来,动态类型在动态绑定中使用,但有时候,动态类型却能在静态方法中使用,请看下面的示例:代码
public class Program
{
static void Test(int i, string s) { Console.WriteLine("int and string"); }
static void Test(string s, int i) { Console.WriteLine("string and int"); }
static void Main()
{
int i = 10;
dynamic d = "hello";
Test(i, d); //调用此方法输出”int and string”
}
}
<!--[endif]-->
虽然d是动态类型,但作为参数传递给Test方法后,还是能成功匹配Test(int i, string s)方法,且没有产生编译时异常,说明编译器对动态类型参数d作为静态类型对待的。
七、 不可调用函数
有些函数是不能通过动态绑定调用的,它们是:
1. 扩展方法(通过扩展方法语法调用)
2. 接口成员(特指显示实现的接口成员)
3. 受可访问性限制的方法
理解这些对于理解动态动态绑定非常有用。对于扩展方法,我们知道,是对于某个特定类型的,而且这个类型必须在编译时就能确定,由于动态绑定不能在编译时确定,所有不能动态调用扩展方法,如果执行这种代码,会产生一个RuntimeBinderException异常。如下所示:代码
using System.Dynamic;
namespace DynamicExtensionMethod
{
public class Foo { }
public static class TestExtensionMethod
{
public static void Test(this Foo f)
{
Console.WriteLine("Foo class’s extension method.");
}
}
class Program
{
static void Main()
{
Foo f = new Foo();
f.Test();//此处扩展方法正常调用
dynamic d = new Foo();
d.Test();//此处抛出一个RuntimeBinderException异常
}
}
}
<!--[endif]-->
对于显示实现的接口成员,由于实现接口的接口类型可能在另一个程序集的类中,虽然可以调用隐式实现的接口方法,但也不推荐这样做。调用显示实际的接口方法,同样会抛出一个RuntimeBinderException异常。如下所示:
代码using System.Dynamic;
namespace DynamicInterface
{
interface IFoo { void Test(); }
class Foo : IFoo
{
void IFoo.Test() { Console.WriteLine("Test"); }
public void SayHello() { Console.WriteLine("hello"); }
}
class Program
{
static void Main()
{
IFoo f = new Foo();
dynamic d = f;
d.SayHello();//此处正常调用
d.Test();//此处抛出RuntimeBinderException异常
}
}
}
<!--[endif]-->
受访问性限制的方法也是不能通过动态绑定调用的,不管是当前类或者当前类的任何基类,由类的封装性所决定,如下代码所示:
代码using System.Dynamic;
namespace CallBaseMember
{
class BaseClass
{
private void Test() { Console.WriteLine("Base Class Test"); }
}
class SubClass : BaseClass
{
private void Print() { Console.WriteLine("Subclass’s print()"); }
}
class Program
{
static void Main()
{
SubClass subc = new SubClass();
dynamic d = subc;
d.Test();//抛出一个RuntimeBinderException异常
d.Print();//抛出RuntimeBinderException异常
}
}
}
<!--[endif]-->
九、 动态绑定的局限性
动态绑定能减少我们的类型转换次数,提升开发速度,但同时也有着它的局限性,主要有:
1. 有限的IDE支持
2. 通常情况下,意味更低的性能。特别是第一次调用方法的时候,因为DLR还没有缓存方法调用。
3. 更加复杂的开发
十、 总结
C# 4.0的动态绑定是基于DLR之上,它使我们在C#中实现动态语言编程,让我们的开发速度变得更快。
参考文献:1、《C# 4.0 in nutshell》 4th Edtion,作者:Joseph Albahari, Ben Albahari;
2、《Introducing .NET 4.0 With Visual Studio 2010》,作者:Alex Mackey。
【C#4.0】中的dynamic与var的区别
注意:var与dynamic这两个关键字,只是看起来很相 似,仅此而已!
var表示“变量的类型是在编译时决定的”,但是dynamic表 示“变量的类型是在运行时决定的”。因此,dynamic与var具有截然不同的含义。
var让 你在初始化变量时少输入一些字,编译器会根据右值来推断出变量的类型。dynamic更厉害,它告诉编译器,根本就别理究竟是啥类型,运行 时再推断不迟。
var只能用于局部变量的定义,你不能把类的属性定义成 var,也不能把方法的返回值类型或者是参 数类型定义成var。dynamic就没有这些局限了。
dynamic类型并没有跳过类型校验,只是 延迟到了运行时。如果在运行时,检测到类型不兼容,照样会抛出异常。
你可能在以下情况下使用dynamic:
1.COM对象
2.动态语言(如IronPython,IronRuby等)对象
3.反射对象
4.C# 4.0中动态创建的对象