Over the last week I have been watching a number of sessions that were recorded at PDC. One that I particularly enjoyed was Anders Hejlsberg “Future of C#”.
During this talk Anders provides a brief introduction to dynamics support in C#. If you’re not sure what dynamics really are then the best way to describe it is the ability to perform lazy evaluation of an objects data type & members at runtime. To make this clearer we can look at C# as it stands today as a purely static language. If we define a new class within c# 3.5 show below we are generally bound to use only the members that have been defined on the contract.
public class PlainOldObject
{
public string Name { get; set; }
public int Age { get; set; }
}
Now when it comes to using the PlainOldObject class we can only do so in a limited way as compilation will fail if we try to access properties that do not exist. Take for example
PlainOldObject plainOldObject = new PlainOldObject();
plainOldObject.Name = "Dave Hanson";
plainOldObject.Age = 30;
plainOldObject.FavouriteLanguage = "c#";
This fails compilation with an error of “'PlainOldObject' does not contain a definition for 'FavouriteLanguage'”. In order to get this code to compile in our current c# 3.5 code we need to go back to the class and implement a new property called FavouriteLanguage of type string.
Introducing the Dynamic Type
Dynamics support in c# 4.0 solves this issue for us! In C# 4.0 a new static type is being introduced called dynamic. The dynamic type tells the c# compiler to ignore type checking at compile and instead leave the evaluation until runtime. The dynamic type can be applied to any .net type but more importantly it can be applied to external resources such as XML, COM objects and Scripts.
So given we have late binding of members now supported in C# 4.0 with the use of the dynamic type what will our code example from above look like. This is show below.
dynamic plainOldObject = new PlainOldObject();
plainOldObject.Name = "Dave Hanson";
plainOldObject.Age = 30;
plainOldObject.FavouriteLanguage = "c#";
As you can see the code looks almost identical. Apart from the dynamic keyword nothing else has changed. However, under C# 4.0, when you go to compile you will not be faced with a compilation error as was shown before. At this point we can see that the compiler is no longer checking all the members of the type during compile but we are still faced with the issue that our PlainOldObject does not actually implement the property FavouriteLanguages. In fact, running the code will cause an exception to be throw.
The next issue we need to solve is how we go about create a dynamic object that can be extended arbitrarily. To do this, we follow the approach most dynamic languages follow. As types have no fixed structure in dynamic languages they must store their data in a generic way, therefore they often implement an internal collection within the type which will store data for each dynamic property is set. Implementing this pattern in C# 4.0 is relatively straight forward.
Introducing DynamicObject
In order for us to create our own dynamic objects Microsoft have provides us with an abstract class called DynamicObject. This abstract class has a number of virtual methods which we can override and that provide interceptors for all method invocations, property getters and setters as well some other useful functions. This is shown below.
public abstract class DynamicObject : IDynamicObject
{
public virtual object GetMember(GetMemberBinder info);
public virtual object SetMember(SetMemberBinder info, object value);
public virtual object DeleteMember(DeleteMemberBinder info);
public virtual object UnaryOperation(UnaryOperationBinder info);
public virtual object BinaryOperation(BinaryOperationBinder info, object arg);
public virtual object Convert(ConvertBinder info);
public virtual object Invoke(InvokeBinder info, object[] args);
public virtual object InvokeMember(InvokeMemberBinder info, object[] args);
public virtual object CreateInstance(CreateInstanceBinder info, object[] args);
public virtual object GetIndex(GetIndexBinder info, object[] indices);
public virtual object SetIndex(SetIndexBinder info, object[] indices, object value);
public virtual object DeleteIndex(DeleteIndexBinder info, object[] indices);
public MetaObject IDynamicObject.GetMetaObject();
So in order to allow our PlainOldObject to support dynamic behaviour we need to inherit the DynamicObject class and then override the GetMember and SetMember methods. In our implementation of these methods we need to ensure that if the SetMember is called we place a value into the internal dictionary of values held within PlainOldObject and if the GetMember is called we need to retrieve the value. Below is an example of this code.
public class PlainOldObject : DynamicObject
{
private Dictionary<string,object> _members = new Dictionary<string,object>();
public override object GetMember(GetMemberAction member)
{
return _members[member.Name];
}
public override object SetMember(SetMemberAction member, object value)
{
_members[member.Name] = value;
}
And that’s it.... were done. We now have an extensible dynamic object that can be extended without having to implement new properties.
dynamic plainOldObject = new PlainOldObject();
plainOldObject.Name = "Dave Hanson";
plainOldObject.Age = 30;
plainOldObject.FavouriteLanguage = "c#";
plainOldObject.Height = 6.0;
plainOldObject.Sex = "Male";
plainOldObject.Foo = "Bar"