Before we dig into the first C# feature, let it be known that Microsoft has promised that any capability found in C# will be offered in VB and vice versa in some fashion. However, they will not necessarily offer it the same way and the languages are expected to continue to diverge.
With the increasing importance of dynamic languages and the DLR, C# needs to be able to work with dynamically typed objects. Currently it is possible to make late bound calls via reflection for static classes, but this takes a lot of code. Moreover, calls to DLR objects require an entirely different call using the DLR's reflection libraries.
In C#, you simply declare the object's static type as "dynamic". Like VB's Option Explicit Off, this tells the compiler to emit the necessary code to resolve the method binding at runtime calls. At the IL, variables declared as dynamic are really of type System.Object with an additional tag indicating it uses dynamic calling semantics.
At runtime all of the normal overload resolution rules work against the object's runtime type. This means you get the ability to perform multiple dispatch directly instead of jumping through reflection or using visitor patterns.
Each dynamic language has its own rules for member lookup. To support this object can implement the IDynamicObject interface. If it exists on the runtime object, the object gets to handle its own member lookup. In the demonstration, Anders showed how to define a dynamic object in C# itself.
And of course, all this means you can use duck typing wherever you want in C#.
Community comments
Code Example
by Chuck Canning,
Re: Code Example
by Jonathan Allen,
Re: Code Example
by Pablo García,
Re: Code Example
by Jonathan Allen,
Multiple dispatch
by srdjan marinovic,
Re: Multiple dispatch
by Jonathan Allen,
Code Example
by Chuck Canning,
Your message is awaiting moderation. Thank you for participating in the discussion.
It would be nice to show an example of what this would look like to the developer.
Re: Code Example
by Jonathan Allen,
Your message is awaiting moderation. Thank you for participating in the discussion.
Sorry about that. Here is an example:
As you can see, there really isn't much to it.
Re: Code Example
by Pablo García,
Your message is awaiting moderation. Thank you for participating in the discussion.
It would be nicer to do:
var obj = [some function];
obj.Foo();
Multiple dispatch
by srdjan marinovic,
Your message is awaiting moderation. Thank you for participating in the discussion.
I am quite curious about this quote: "At runtime all of the normal overload resolution rules work against the object's runtime type. This means you get the ability to perform multiple dispatch directly..."
Does this mean that the dispatching is done on all runtime types for the method parameters, ala CLOS? And how is this specific to dynamic type?
Thank you for the time and help
Kind regards
Srdjan
Re: Code Example
by Jonathan Allen,
Your message is awaiting moderation. Thank you for participating in the discussion.
The thing is, var is just a place holder while dynamic is a type. This means you can write:
Re: Multiple dispatch
by Jonathan Allen,
Your message is awaiting moderation. Thank you for participating in the discussion.
Lets say you have this code:
What happens is the runtime asks object a "What should happen when I call 'Bar' with types b.GetType and c.GetType?". If a is a python object the answer may very well be different than is a is a C# object.
Since the decision is being made entirely at runtime, I would expect you see to see CLOS-like dispatching.