I stumbled about this post over at Jon's blog called "C# 4.0: dynamic<T> ?". In it Jon wonders about the dynamic keyword and if there should be a generic version of it. That way we could be sure that the dynamic implements for example a certain interface. We all know that to be some sort of duck typing.

I got curious about it and started a little project. All I wanted to achieve is that the following would work:

PLAIN TEXT
C#:
  1. int i = 1;
  2. dynamic d = new Duck();
  3. d.Test = i;
  4. dynamic a = d.Test;
  5.  
  6. Console.WriteLine(a);
  7.  
  8. // Duck!?
  9. IQuack t = d;
  10. Console.WriteLine(t.Test);
  11. t.Test = "2";
  12. Console.WriteLine(t.Test);

(where IQuack is an interface that has a Test { get; set; } signature.)

The challenge was to make Duck absolutely dynamic and certainly not aware of any IQuack interface since that would certainly be cheating. ;)

To get a dynamic class in C# 4.0 the class has to implement System.Scripting.Actions.IDynamicObject which has one method called

PLAIN TEXT
C#:
  1. System.Scripting.Actions.MetaObject GetMetaObject(System.Linq.Expressions.Expression parameter)

At this point I encourage you to download the code sample and read along, because I will not get into every detail: blog.ducktyping source (zip)

Have you downloaded the source? Now, open the solution in Visual Studio 2010, go to Program.cs and you will notice that of course the intellisense won't work before IQuack t = d; but certainly afterwards. No biggy right?! :)

Implementing a dynamic class
During the next steps I will create a dynamic class that dynamically takes any Property one wishes to attach to it, and save the value for those Properties in a simple Dictionary<string,string>.

We already talked about it, that the Duck class will be our dynamic class. In order to make it dynamic we have to implement (at first) one supporting classes. Namely: MetaDuck. This class is derived from MetaObject and is returned in order to satisfy the IDynamicObject interface and to customize the behavior of our Duck.

In MetaDuck we can now override certain interesting methods. In order to make the first 5 lines of our Main method work we have to override GetMember and SetMember because we want to customize our dynamic member handling.

The trick is to pass the instantiated duck in the constructor of MetaDuck and pass it to the base class in order to enable us to work on its methods. I won't go into the details of what the expression tree is doing. Just these hints:

  • Expression.Convert(Expression, LimitType) enables us to operate on the instanciated duck we passed in the constructor.
  • We dynamically call the method on Duck (eg. SetMember).

Enabling that dynamic class to cast itself into strongly typed world
The main challenge now is to make our dynamic class fully capable of behaving like a strongly typed class. For that to be possible we will utilize dynamic proxies generated by Castle.DynamicProxy.ProxyGenerator. For that we need to override Convert in MetaDuck and implement the supporting IInterceptor. Basically we need to capture any member access through said proxy, and rewire it to our dynamic methods:

PLAIN TEXT
C#:
  1. public void Intercept(IInvocation invocation) {
  2.    if (invocation.Method.Name.StartsWith("get_")) {
  3.       invocation.ReturnValue = dynamicElement.GetMember(invocation.Method.Name.Substring(4));
  4.    }
  5.    else if (invocation.Method.Name.StartsWith("set_")) {
  6.       dynamicElement.SetMember(invocation.Method.Name.Substring(4), invocation.Arguments[0]);
  7.    }
  8.    else {
  9.       throw new MissingMethodException();
  10.    }
  11. }

Plus we have to return the proxy when a cast is requested:

PLAIN TEXT
C#:
  1. public virtual object Convert(ConvertAction action) {
  2.    return Generator.GenerateProxy(action.ToType, this);
  3. }

That's it
Well, basically that's what's needed to make all of this work:

PLAIN TEXT
C#:
  1. int i = 1;
  2.            
  3. dynamic d = new Duck();
  4. d.Test = i;
  5. dynamic a = d.Test;
  6.  
  7. Console.WriteLine(a);
  8. Console.WriteLine(a.GetType().FullName);
  9.  
  10. // Duck!?
  11. IQuack t = d;
  12.  
  13. Console.WriteLine(t.Test);
  14.  
  15. t.Test = "2";
  16. // Would not compile anymore:
  17. // t.Test = i;
  18.  
  19. Console.WriteLine(t.Test);
  20.  
  21. try
  22. {
  23.    Console.WriteLine(t.NotSet);
  24.    Console.WriteLine("You should never see this");
  25. }
  26. catch (MemberAccessException)
  27. {
  28.    Console.WriteLine("Caught expected MemberAccessException");
  29. }
  30.  
  31. t.NotSet = "3";
  32.  
  33. Console.WriteLine("Should work now: " + t.NotSet);

We can see,

  • totally dynamic behavior: in line 4 the i gets excepted, even though it is not a string. We can't do that any more in line 17, when using the statically typed interface.
  • Bringing a dynamic type back to the static typed world in line 11
  • The dynamic type revolting when a property gets accessed that it doesn't know (yet) in line 23. (Which by the way is the behavior I _chose_ to give it. You can behave in any way you want, all you have to do is change GetMember in Duck.)
  • The dynamic type "learning" a new property in line 31 even though it is strongly typed.

Even though I had a lot of fun getting this to work I can truly say that dynamic is a double edged sword that must be handled with care. But with a proper implementation of Convert this new type of dynamic behavior opens a lot of doors without killing threatening the static world too much.

Download: blog.ducktyping source (zip)

kick it on DotNetKicks.com

Post to Twitter Tweet this