Declarative multithreading

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ThreadBound
{
    /// <summary>
    /// Implements the extension Method for the class Object that allows binding iterfaces to threads.
    /// </summary>
    public static class ThreadBoundInterface
    {
        /// <summary>
        /// Creates an interface where all method calls are executed within the current thread.
        /// </summary>
        /// <typeparam name="T">Type of the interface that should be bound to this thread.</typeparam>
        /// <param name="realObject">Reference to the real object instance. The referenced object must implement T.</param>
        /// <returns>Returns an instance of a proxy class implementing interface T.</returns>
        /// <example><code>
        ///     IUpdateInterface threadBoundUpdater = this.BindInterfaceToThread<IUpdateInterface>();
        /// </code></example>
        static public T BindInterfaceToThread<T>(this Object realObject) where T : class 
        {
            SynchronizationContext executionContext = SynchronizationContext.Current;

            //-- To bind an interface to a thread a proxy must be generated on the fly. This proxy
            //   forwards all calls to the real instance but is derived from ContextBoundObject.
            //   This is very time consuming and should only be used if neccessary. But it's working pretty well.
            MarshalByRefObject wrapper = InterfaceProxyGenerator.CreateProxy((T)realObject);

            //-- Create a proxy from the existing object and return an instance of the transparent proxy hat
            //   was created for the proxy class. (TransparentProxy -> RealProxy -> InterfaceProxy -> Interface)
            ThreadBoundProxy newProxy = new ThreadBoundProxy(typeof(T), (MarshalByRefObject)wrapper, executionContext);
            return (T)newProxy.GetTransparentProxy();
        }
    }
}