The other day an interesting question was posed on Stackoverflow. Sumarizing:

"How can I add methods to a type dynamically at runtime and have them be available to all other instances of that type?"

That is certainly an interesting question. Of course this is similar to how JavaScript works via the prototype property that all objects have. So I set out to see how easy it would be to simulate prototypal inheritance in C# using the new Dynamic Language Runtime features introduced in C# 4.0.

Now let me preface this by saying this solution is an answer in search of a question. That is, there is no particular problem I can immediately think of that this solves. It is a decent demonstration of the dynamic capabilities available to you in C#, but if you find yourself needing this kind of behavior, you might be a closet hipster.

What would such an implementation look like? Imagine the following class structure:

public class Foo {}
public class Bar: Foo {}

And now we would like to be able to dynamically define methods for Foo and Bar at runtime like so.

var foo1 = new Foo();
var foo2 = new Foo();

Foo.Add = new Func<Int32,Int32,Int32>((a, b) =>; a + b);

var result1 = foo1.Add(5, 5); // result1 == 10
var result2 = foo2.Add(10, 5); // result2 == 15

As it is written, this is impossible since it won't even compile. However, if we leverage the DLR and the dynamic keyword, then we can begin to make some magic happen. ExpandoObject is certainly an attractive new addition to .Net, as it allows us to dynamically add members at runtime, but they are local to that instance only. So for our purposes we are going to have to turn to the low level DynamicObject. DynamicObject gives us hooks into the new dynamic features of the runtime, but we are forced to write all the necessary plumbing to get the functionality we want. At a minimum we need to be able to:

• Add new properties
• Add new methods
• Retrieve the value of dynamic properties
• Invoke dynamically added methods

This turns out to be pretty easy by overriding just three methods from DynamicObject. TrySetMember, TryGetMember and TryInvokeMember.

public class ProtoObject : DynamicObject
{
 private Dictionary<String,Object> _members = new Dictionary<String,Object>();

 public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
 {
  Object member = null;
  result = null;

  //Check to see if we have a member of this name
  var success = _members.TryGetValue(binder.Name, out member);

  //Check to make sure it is a delegate that can be invoked
  if (success && member is Delegate)
  {
   //Execute the member with the passed in arguments and assing the result
   result = ((Delegate)member).DynamicInvoke(args);
  }

  return success;
 }

 public override bool TryGetMember(GetMemberBinder binder, out object result)
 {
  //Attempt to get the saved value with specified name
  var success = _members.TryGetValue(binder.Name, out result);

  return success;
 }
 
 public override bool TrySetMember(SetMemberBinder binder, object value)
 {
  //Add the new member name and value to our dictionary
  // or override the existing value
  if (_members.ContainsKey(binder.Name))
   _members[binder.Name] = value;
  else
   _members.Add(binder.Name, value);

  return true;
 }
}

Now we have a custom object that will act similar to how ExpandoObject works. However, we still haven't solved the issue of inheriting members across all types. What we need is a shared collection of members that are specific to that type.
 
I've chosen a static Dictionary<Type,ExpandoObject> for this solution. Obviously we want to use Type as a key since the members should be specific to a type, and ExpandoObject already gives us all the functionality we need to store a collection of arbitrary properties and methods.

In order to make this work properly, we need to initialize the Dictionary with each new type in the inheritance chain, and provide a humane way of adding new members to a specific type. The constructor can be used to ensure that new types are added to the Dictionary, and by getting creating with the dynamic keyword, we can add a Prototype property that will give each type access to it's corresponding ExpandoObject.

private static readonly Dictionary<Type,ExpandoObject> _prototypes = new Dictionary<Type,ExpandoObject>();

public ProtoObject()
{
 if (Prototype == null)
 {
  _prototypes.Add(GetType(), new ExpandoObject());
 }
}

public dynamic Prototype
{
 get
 {
  if (_prototypes.ContainsKey(GetType()))
   return _prototypes[GetType()];
  else
   return null;
 }
}

Finally, when a request for a member is made, we need to first check to see if there is one defined on the instance. If we can't find one, then we can begin looking for a matching member in the prototype object, walking the inheritance chain until we find what we are looking for.

Since finding an appropriate prototype member by walking the inheritance chain is recursive in nature, a helper method can be added to make this easier. While TrySetMember remains unchanged, TryInvokeMember and TryGetMember need to change slightly to accommodate the new functionality, but not by much.

public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
 Object member = null;
 result = null;

 var success _members.TryGetValue(binder.Name, out member);

 if (success && member is Delegate)
 {
  result = ((Delegate)member).DynamicInvoke(args);
 }

 if (!success)
 {
  member = FindPrototypeMember(binder.Name, GetType());

  if (member is Delegate)
  {
   result = ((Delegate)member).DynamicInvoke(args);
   success = true;
  }
 }

 return success;
}

public override bool TryGetMember(GetMemberBinder binder, out object result)
{
 var success = _members.TryGetValue(binder.Name, out result);

 if (!success)
 {
  var member = FindPrototypeMember(binder.Name, GetType());

  if (member != null)
  {
   result = member;
   success = true;
  }
 }

 return success;
}

//Walk the inheritance chain using recursion to find a suitable
// prototype member
private object FindPrototypeMember(string memberName, Type type)
{
 if (String.IsNullOrWhiteSpace(memberName) || type == null) return null;

 if (!_prototypes.ContainsKey(type)) return null;

 var prototype = _prototypes[type] as IDictionary;

 if (prototype.ContainsKey(memberName))
  return prototype[memberName];
 else
  return FindPrototypeMember(memberName, type.BaseType);
}

Putting this all together allows us to inherit from this object and dynamically add members and properties at runtime that will be available to all instances of that type. In other words, given this class structure:

public class Foo: ProtoObject {}
public class Bar: Foo {}

This code is totally valid:

dynamic myFoo = new Foo();
dynamic yourFoo = new Foo();
dynamic myBar = new Bar();

myFoo.Prototype.Name = "Josh";
myFoo.Prototype.SayHello = new Action(s => Console.WriteLine("Hello, " + s));

yourFoo.SayHello(myBar.Name); // 'Hello, Josh'

Again, I can't think of any practical use for this off the top of my head, but it is interesting to see just how much flexibility you can squeeze out of C# with very little code. 

For those who are interested a more robust version of this code is available on GitHub. The unit tests are the best documentation of the additional features, mainly:

• Ability to check for "undefined" members by returning a special value instead of throwing an exception
• Ability to access the current instance from within dynamically added methods.
• Allows original exception with full stack trace to propogate instead of a RuntimeBinderException.