Chris Burrows' Blog : DLR

MSDN Channel 9 Video on Dynamic

cburrows — Wed, 23 Sep 2009 00:44:33 GMT

About a month ago, Sam Ng and I sat down with Charlie Calvert and his video camera to record an interview-style video about dynamic. Have a look!

http://channel9.msdn.com/posts/CharlieCalvert/CSharp-4-Dynamic-with-Chris-Burrows-and-Sam-Ng/

If you view it, I hope you find it helpful and informative. Also, I clearly need to take some kind of instruction on what to do with oneself on video when the other person is talking. That pen was very interesting.

C# "dynamic," Part III

cburrows — Wed, 29 Oct 2008 06:59:14 GMT

Here are a few good resources that you ought to look at for information about dynamic from PDC:

Anders Hejlsberg's talk, "The Future of C#" - Among other things, this talk is a great introduction to dynamic. I recommend it highly! There are some good demos, and Anders' presentation is very compelling. I especially like the parts where people applaud.

Jim Hugunin's talk, "Deep Dive: Dynamic Languages in Microsoft .NET" - Jim is the DLR's architect. There are some details about implementing your own dynamic objects, which I touched on only superficially yesterday. He also talks about the way that C# (or any language) generates dynamic call sites and what they do at runtime.

Mads Torgerson's white paper, "New features in C# 4.0" - Some more information, this time written by the language PM. Mads is the guy who'll ultimately write and edit the updated language spec, which doesn't yet exist.

If you watch these presentations, and you start to play around with the PDC 2008 CTP, you may notice something strange. A few things just won't work. For instance, when you try to get an indexer on a dynamic (d[0]) or perform a binary operation with a dynamic ("Hello from C# " + d), the compiler is going to tell you you can't do that. And in Jim's talk, he implements IDynamicObject with a great helper class called DynamicObject where you only need to override some virtual methods. But the PDC bits don't have that type.

It may be obvious, but the thing that's going on here is that the CTP build for PDC was snapped sometime in the summer, and some of the presenters are using a newer, more complete build. We've done a lot of work since the CTP was snapped, and I regret that you can't see it all first hand right now, but I hope you'll understand that this is the nature of a CTP. I'll try to be clear when I post about what will work for you, and what won't.

For instance, Part II in this series (the implementation of IDynamicObject) will work for you! I don't think Part I will, though (it uses indexers).

If you're wondering what does work for dynamic C# in the CTP build, here's the short story: (a) dynamic method calls, (b) dynamic property gets/sets, and (c) dynamic conversion sites.

Previous posts in this series: C# "dynamic"; C# "dynamic," Part II

C# "dynamic," Part II

cburrows — Tue, 28 Oct 2008 19:31:00 GMT

Yesterday, I made an attempt to introduce the C# dynamic feature by describing what change there has been to the language, what scenarios we hope to affect by that change, and some overview of what dynamic operations look like in C# 4 as it stands in the preview distributed at PDC 2008.

One thing that I did not mention was this: that the language changes are entirely focused around consumption of dynamic types, not definition of those types. This is not to say that you cannot define dynamic types--just that the C# language has not change in any way so as to provide you a shortcut. We have not added a "method_missing," nor are any of the regular types you define in C# capable of somehow dynamically acquiring properties. And you can't say something like "dynamic class C" to define such a class.

If you want to define a new type that accepts dynamic operations, then it's easy to do so, and you don't even need C# 4. You just implement IDynamicObject, which is the interface that tells the DLR, "I know how to dispatch operations on myself." It's a simple interface, in the spirit of IQueryable, with a single method that returns a "MetaObject" to do the real heavy lifting.

I want to make clear at this point that I am about to provide an example of how to use the DLR, but that I am only doing so in order to demonstrate how these objects play with the C# 4 language features. There are other blogs that are certainly better sources for information about the DLR.

So, here's an implementation:

public class MyDynamicObject : IDynamicObject
{
  public MetaObject GetMetaObject(Expression parameter)
  {
    return new MyMetaObject(parameter);
  }
}

Simple enough! Here's the MyMetaObject definition. The MetaObject "knows how" to respond to a variety of actions including method calls, property sets/gets, etc. I'll just handle those (no best practices here; this is a minimal implementation):

public class MyMetaObject : MetaObject
{
  public MyMetaObject(Expression parameter)
    : base(parameter, Restrictions.Empty)
  {
  }
  
  public override MetaObject Call(CallAction action, MetaObject[] args)
  {
    Console.WriteLine("Call of method {0}", action.Name);
    return this;
  }

  public override MetaObject SetMember(SetMemberAction action, MetaObject[] args)
  {
    Console.WriteLine("SetMember of property {0}", action.Name);
    return this;
  }

  public override MetaObject GetMember(GetMemberAction action, MetaObject[] args)
  {
    Console.WriteLine("GetMember of property {0}", action.Name);
    return this;
  }
}

This is exactly what, say, IronPython might do to implement the dictionary lookup that it needs to do for its members. And when I say "exactly," I mean "sort of" because of course IronPython's implementation is considerably more complex and robust. But this gets the job done. Suppose I want to now use C# to invoke these things using the new syntax. That's the easy part! Check this out:

public class Program
{
  static void Main(string[] args)
  {
    dynamic d = new MyDynamicObject();

    d.P3 = d.M1(d.P1, d.M2(d.P2));
  }
}

So I take my MyDynamicObject that I defined above, and then I get a few properties, call a few methods, and set a property for good measure. If you compile this, you get the following output:

GetMember of property P1
GetMember of property P2
Call of method M2
Call of method M1
SetMember of property P3

I think that's pretty cool.

Next time I'll talk more about the dynamic type again, in the C# language, and how it behaves. I just wanted to take a little diversion to clear up the fact that we've really done a lot of cool work on the consumption side, and your code ought to look better for it when you're consuming these things. If you're defining them, then you're in DLR-land, and you might even be writing in python or ruby or some other language. I'll provide pointers to those issues as I get them.

Previous posts in this series: C# "dynamic"