Dass C# 4 Unterstützung für dynamische Objekte bringen wird, dürfte dem einen oder anderen bereits bekannt sein. Damit soll das Zusammenspiel mit dynamischen Sprachen und COM sowie das Abbilden von dynamischen Domänen erleichtert werden.

Daneben wird jedoch auch die Möglichkeit geboten, eigene Klassen zu entwickeln, welche dynamische Member haben und somit erst zur Laufzeit aufgelöst werden. Das nachfolgend dargestellte Beispiel demonstriert dies, indem eine Instanz von Something erzeugt wird und dieser Werte für zwei bis dato nicht definierte (!) Eigenschaften zugewiesen werden. Danach werden diese wieder ausgelesen und auf der Konsole ausgegeben.

Anschließend werden mit einer Methode RegisterMethod zwei Delegates als Methoden definiert. Die Namen dieser neuen Methoden werden als String übergeben. Danach werden beiden Methode, wie herrkömmliche Methoden, aufgerufen. Im Anschluss daran, wird auch noch das Objekt als Methode behandelt und ausgeführt.
dynamic dontknow = new Something();

dontknow.X = 10;
dontknow.Y = 20;

Console.WriteLine(dontknow.X);
Console.WriteLine(dontknow.Y);

Func<int,int,int> add = (x,y) => x + y;
Func<int, int, int> sub = (x, y) => x - y;

dontknow.RegisterMethod("Add", add);
dontknow.RegisterMethod("Sub", sub);

Console.WriteLine(dontknow.Add(1,2));
Console.WriteLine(dontknow.Sub(1, 2));
Console.WriteLine(dontknow(1, 2));

Möglich wird dies, indem Something von DynamicObject erbt und dessen Methoden überschreibt. Diese Methoden werden von .Net immer dann aufgerufen, wenn bestimmte Aktionen mit dynamischen Membern durchgeführt werden sollen. Die Methode TrySetMember wird beispielsweise angestoßen, wenn eine dynamische Eigenschaft gesetzt werden soll; TrySetMember, wenn eine solche ausgelesen werden soll und TryInvokeMember wenn eine dynamische Methode zur Ausführung zu bringen ist. Wird, wie oben gezeigt, eine Instanz als Methode behandelt, delegiert das Framework an TryInvoke weiter.

Der gesamte Quellcode für dieses Beispiel findet sich nachfolgend.
class MethodNotFoundException : Exception
{
    public MethodNotFoundException(string message): base(message) { }
}

class Something : DynamicObject
{
    private Dictionary<String, dynamic> fields = new Dictionary<string, dynamic>();
    private Dictionary<String, Delegate> methods = new Dictionary<string, Delegate>();
    private Delegate firstMethod = null;

    public void RegisterMethod(String name, Delegate d)
    {
        if (methods.Count == 0) firstMethod = d;
        methods[name] = d;
    }

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        result = fields[binder.Name];
        return true;
    }

    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        fields[binder.Name] = value;
        return true;
    }
   
    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        if (!methods.ContainsKey(binder.Name)) {
            throw new MethodNotFoundException(binder.Name + " not found!");
        }
        result = methods[binder.Name].DynamicInvoke(args);
        return true;
    }

    public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
    {

        if (firstMethod == null)
        {
            throw new MethodNotFoundException("No default method found!");
        }
        result = firstMethod.DynamicInvoke(args);
        return true;
    }

}

class Program
{
    static void Main(string[] args)
    {
        dynamic dontknow = new Something();

        dontknow.X = 10;
        dontknow.Y = 20;

        Console.WriteLine(dontknow.X);
        Console.WriteLine(dontknow.Y);

        Func<int,int,int> add = (x,y) => x + y;
        Func<int, int, int> sub = (x, y) => x - y;
       
        dontknow.RegisterMethod("Add", add);
        dontknow.RegisterMethod("Sub", sub);

        Console.WriteLine(dontknow.Add(1,2));
        Console.WriteLine(dontknow.Sub(1, 2));
        Console.WriteLine(dontknow(1, 2));

        Console.ReadLine();

    }
}