public class SingletonHost<T> : MarshalByRefObject
        where T : MarshalByRefObject, new()
    {
        private static readonly T instance;

        static SingletonHost()
        {
            instance = (T)Activator.CreateInstance(typeof(T));
        }

        public T Instance
        {
            get { return instance; }
        }
    }

    public class SingletonClient<T> : IDisposable
        where T : MarshalByRefObject
    {
        private const String Mutex_Name = "CrossDomainSingleton";
        private const String Host_Domain_Name = "SingletonDomain";

        private readonly Mutex mutex;

        private IEnumerable<AppDomain> GetAppDomains()
        {
            IntPtr enumHandle;

            var host = new mscoree.CorRuntimeHost();
            host.EnumDomains(out enumHandle);
            try
            {
                Object domain = null;

                do
                {
                    host.NextDomain(enumHandle, out domain);
                    if (domain != null)
                        yield return (AppDomain)domain;
                }
                while (domain != null);
            }
            finally
            {
                host.CloseEnum(enumHandle);
                Marshal.ReleaseComObject(host);
            }
        } 

        public SingletonClient()
        {
            mutex = new Mutex(false, Mutex_Name);
        }

        public T Instance
        {
            get
            {
                mutex.WaitOne();
                try
                {
                    var hostDomain = GetAppDomains().SingleOrDefault(d => d.FriendlyName == Host_Domain_Name);

                    if (hostDomain == null)
                        hostDomain = AppDomain.CreateDomain(Host_Domain_Name);

                    var host = (SingletonHost<T>)hostDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName,
                        typeof(SingletonHost<T>).FullName);

                    return host.Instance;
                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }
        }

        #region IDisposable Members

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(Boolean disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                if (mutex != null)
                    mutex.Dispose();
            }

            disposed = true;
        }

        private Boolean disposed;

        #endregion
    }