In the previous article I showed how one could construct a weak proxy object using LinFu. This idea very slick, but it doesn’t do us much good unless there is something built around it.

DISCLAIMER: Blocks of this code are taken directly from the Ninject 2.0 source base and re-purposed. All code in this article is released under the same licenses as the source works (Apache 2 and MS-PL).

To start, we have IWeakCache (formerly ICache.cs) and ICachePruner to describe our cache backing and the cleanup strategy. The IWeakCache is like the Ninject ICache except that I don’t provide the Get method and it takes a Weak> pointer and the source object. We can watch the weak reference for cleanup and execute it on the original object.

    public interface IWeakCache
    {
        void Remember<T>( Weak<WeakInterceptor<T>> reference, T instance );

        void Prune();

        void Clear();
    }

    public interface ICachePruner
    {
        void Start( IWeakCache cache );

        void Stop();
    }

I use the GarbageCollectionCachePruner directly from Ninject but change the ICache and ICachePruner interfaces to my own.

Given that I need to create my own cache to monitor weak references, I modified the Cache.cs file to accommodate this.

    public class WeakProxyCache : IDisposable, IWeakCache
    {
        private readonly Multimap<Type, CacheEntry> _entries = new Multimap<Type, CacheEntry>();

        #region Implementation of IWeakCache

        public void Remember<T>( Weak<WeakInterceptor<T>> reference, T instance )
        {
            lock ( _entries )
            {
                CacheEntry entry = CacheEntry.FromObject( reference, instance );
                _entries[entry.Service].Add( entry );
            }
        }

        public void Prune()
        {
            lock ( _entries )
            {
                List<CacheEntry> expiredValues = _entries
                    .SelectMany( entry => entry.Value )
                    .Where( item => !item.Scope.IsAlive )
                    .ToList();
                expiredValues.ForEach( Forget );
            }
        }

        public void Clear()
        {
            lock ( _entries )
            {
                _entries
                    .SelectMany( e => e.Value )
                    .ToList()
                    .ForEach( entry => _entries[entry.Service]
                                           .Remove( entry ) );
            }
        }

        #endregion

        private void Forget( CacheEntry entry )
        {
            _entries[entry.Service].Remove( entry );
            var disposable = entry.Instance as IDisposable;
            if ( disposable != null )
            {
                disposable.Dispose();
            }
        }

        #region Implementation of IDisposable

        protected bool IsDisposed { get; private set; }

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

        public void Dispose( bool disposing )
        {
            if ( disposing &amp;&amp; !IsDisposed )
            {
                Clear();
                IsDisposed = true;
            }
        }

        #endregion

        #region Nested type: CacheEntry

        protected class CacheEntry
        {
            public WeakReference Scope { get; private set; }
            public Type Service { get; private set; }
            public object Instance { get; private set; }

            public static CacheEntry FromObject<T>( WeakReference reference, T instance )
            {
                return new CacheEntry
                       {
                           Scope = reference,
                           Instance = instance,
                           Service = typeof (T)
                       };
            }
        }

        #endregion
    }

With this, I now have everything I need to create my WeakProxyFactory. I set up the .ctor to take an IWeakCache and ICachePruner so that we can adjust the storage and cleanup as needed. In this class, I am actually using the CommonServiceLocator to get the real object instance.

    public class WeakProxyFactory
    {
        private readonly IWeakCache _defaultProxyCache;
        private readonly ICachePruner _defaultProxyCachePruner;
        private readonly ProxyFactory _proxyFactory;

        public WeakProxyFactory()
            : this( new WeakProxyCache(), new GarbageCollectionCachePruner() )
        {
        }

        public WeakProxyFactory( IWeakCache cache, ICachePruner cachePruner )
        {
            _proxyFactory = new ProxyFactory();
            _defaultProxyCache = cache;
            _defaultProxyCachePruner = cachePruner;
            _defaultProxyCachePruner.Start( _defaultProxyCache );
        }

        public virtual T GetProxy<T>()
        {
            var instance = GetInstance<T>();

            T proxy = WrapInstance( instance );

            return proxy;
        }

        protected virtual T WrapInstance<T>( T instance )
        {
            var weakReference = new Weak<WeakInterceptor<T>>(
                new WeakInterceptor<T>(
                    new Weak<T>( instance ) ) );

            _defaultProxyCache.Remember( weakReference, instance );

            var proxy = _proxyFactory.CreateProxy<T>( weakReference.Instance );
            return proxy;
        }

        protected virtual T GetInstance<T>()
        {
            return ServiceLocator.Current.GetInstance<T>();
        }
    }

Now you can create a weak proxy simply by using the factory, or setting it up in an IoC container. To use the previous example of hooking IFoo to Foo, and injecting the weak reference into Baz objects, I can configure my application. This is going to look like a lot, but I am just being overly verbose showing how everything is set up.

    public class WeakProxyProvider<T> : Provider<T>
    {
        #region Overrides of Provider<T>

        protected override T CreateInstance( IContext context )
        {
            return context.Kernel.Get<WeakProxyFactory>().GetProxy<T>();
        }

        #endregion
    }

        public static void Configure()
        {
            IKernel kernel = new StandardKernel();
            kernel.Bind( typeof (WeakProxyProvider<>) ).ToSelf().InSingletonScope();
            kernel.Bind<IFoo>().ToProvider<WeakProxyProvider<Foo>>().InTransientScope();
            kernel.Bind<Foo>().ToSelf().InTransientScope();
            kernel.Bind<Baz>().ToSelf().InTransientScope();
            kernel.Bind<IWeakCache>().To<WeakProxyCache>().InSingletonScope();
            kernel.Bind<ICachePruner>().To<GarbageCollectionCachePruner>()
                .WithConstructorArgument( "pruneInterval", TimeSpan.FromSeconds( 1 ) );
            kernel.Bind<WeakProxyCache>().ToSelf();
            kernel.Bind<WeakProxyFactory>().ToSelf().InSingletonScope();

            var ninjectServiceLocator = new NinjectServiceLocator( kernel );
            ServiceLocator.SetLocatorProvider( () => ninjectServiceLocator );
        }

So after all of this work, what does it buy me? My Baz objects now have IFoo weak proxy instances automatically injected into them when I make requests to the ServiceLocator. Once I null the pointer to the Foo object, the cache pruner will clean things up:

    public static class SystemTest
    {
        private const int size = 6;

        public static void Run()
        {
            Configure();
            var bazs = new List<Baz>();
            for ( int i = 0; i < size; i++ )
            {
                bazs.Add( ServiceLocator.Current.GetInstance<Baz>() ); // Where the magic happens
            }

            for ( int i = 0; i < size; i++ )
            {
                Baz baz = bazs[i];
                Console.WriteLine( "Foo Id: {0}", baz.Foo.Id );
                baz.Action();
                GC.Collect( 2 );

                baz.Release();
                GC.Collect( 2 ); // The Foo instances are disposed of by the system for you.
                Thread.Sleep( 100 );
            }
        }

So, we have now seen a full implementation of a weak proxy factory handing out weak substitutes for the real objects. But what can we do from here? Is there anything else? YES! Now what we have full control over the real object lifetime, we can implement pooling. So, instead of handing out pointers to new weak objects, I can reuse objects in my pool, or use a lock to wait until a resource is available. These are both potentially big projects, so I am going to keep it small for now and just show a very minimalist example.

He is a small example that will let you set the size of the pool and it will reuse instances. Every time an instance is requested, we will clean the dead objects from the pool and refill if needed.

    public class PoolingWeakProxyProvider<T> : Provider<T>
    {
        private int _currentIndex;
        private List<Weak<T>> _pool = new List<Weak<T>>();

        public PoolingWeakProxyProvider()
            : this( 5 )
        {
        }

        private PoolingWeakProxyProvider( int poolSize )
        {
            PoolSize = poolSize;
            _pool = new List<Weak<T>>();
        }

        #region Overrides of Provider<T>

        protected override T CreateInstance( IContext context )
        {
            lock ( _pool )
            {
                Prune();
                var proxyFactory = context.Kernel.Get<WeakProxyFactory>();
                if ( _pool.Count < PoolSize )
                {
                    var item = proxyFactory.GetProxy<T>();
                    _pool.Add( new Weak<T>( item ) );
                    return item;
                }
                else
                {
                    return _pool[( _currentIndex++ ) % PoolSize].Instance;
                }
            }
        }

        #endregion

        public int PoolSize { get; private set; }

        public void Prune()
        {
            lock ( _pool )
            {
                var expired = _pool
                    .Where( item => !item.IsAlive )
                    .ToList();
                expired.ForEach( item => _pool.Remove( item ) );
            }
        }
    }

Going back to our IoC container configuration (Ninject), we can put these two lines in:

        public static void Configure()
        {
...
            kernel.Bind( typeof (PoolingWeakProxyProvider<>) ).ToSelf().InSingletonScope();
            kernel.Bind<IFoo>().ToProvider<PoolingWeakProxyProvider<Foo>>().InTransientScope();
...
        }

I think that this can potentially be very useful in dealing with items such as WCF proxies. You could keep a pool and trim proxies as they age, and return them to requesters if there is no live usage, but the connection is still good.

I wanted my proxy factory to hand out instances, but clean up the instance as soon as the caller no longer needs the service. I also didn’t want the caller running the cleanup code. This allows me to pool proxy instances and clean them up as I see fit.

There is an inherent issue with this idea: how do I know when the caller is done with the proxy? The answer, while not straight forward, is pretty cool. To start off, we will only consider what we hand off to the caller when the service is requested.

Let’s assume we have and IFoo contract and a Foo service that can be consumed. We want the caller to rely on the contract while we deal with the cleanup. Here is a very simple example.

    public interface IFoo
    {
        void Bar();
    }

    public class Foo : IFoo, IDisposable
    {
        public bool IsDisposed { get; private set; }

        #region IDisposable Members

        public void Dispose()
        {
            IsDisposed = true;
        }

        #endregion

        #region IFoo Members

        public void Bar()
        {
            Console.WriteLine( "Foo::Bar" );
        }

        #endregion
    }

Now we want to hand out IFoo, and allow the caller to release control of the service. This is done most simply in two ways. First, use the pointer to the IFoo service and then go out of scope. Second, hold the IFoo pointer in a member variable and set it to null when done. For the sake of the example, we are going to play with the second option.

    public class Baz
    {
        private IFoo _foo;

        public Baz( IFoo foo )
        {
            _foo = foo;
        }

        public void Action()
        {
            _foo.Bar();
        }

        public void Release()
        {
            _foo = null;
        }
    }

We can supply the IFoo into the Baz instance via dependency injection. When we are done with the IFoo instance, we set the pointer to null, or the GC will do it for us when the object goes out of scope. This gives us a very simple model from which things get a lot more fun.

Weak<T> is the base for this post. It is a WeakReference with strongly typed access to the target instance. This can be optimized, but is much more understandable as-is.

    public class Weak<T> : WeakReference
    {
        public Weak( T target )
            : base( target )
        {
        }

        protected Weak( T target, bool trackResurrection )
            : base( target, trackResurrection )
        {
        }

        protected Weak( SerializationInfo info, StreamingContext context )
            : base( info, context )
        {
        }

        public T Instance
        {
            get { return (T) Target; }
        }
    }

We can extend this class to create a decorator proxy based on the weak reference to the real service:

    public class WeekFoo : Weak<IFoo>, IFoo
    {
        public WeekFoo( IFoo target )
            : base( target )
        {
        }

        protected WeekFoo( IFoo target, bool trackResurrection )
            : base( target, trackResurrection )
        {
        }

        protected WeekFoo( SerializationInfo info, StreamingContext context )
            : base( info, context )
        {
        }

        #region IFoo Members

        void IFoo.Bar()
        {
            Instance.Bar();
        }

        #endregion
    }

Now we have an object with a weak reference base that behaves like an IFoo. There is a drawback to this which should be pretty obvious: you have to generate a proxy for every service you want to track and hand-write every method in the interface. This is where a dynamic proxy framework like Castle.DynamicProxy2 or LinFu.DynamicProxy can save us a lot of time. For the example, I am going to use LinFu. Really, all we want is a wrapper that will use the underlying weak object to make the interface calls for us. We can also set it up to throw if we have released the weak reference.

    public class WeakInterceptor<T> : IInvokeWrapper
    {
        private readonly Weak<T> _target;

        public WeakInterceptor( Weak<T> target )
        {
            _target = target;
        }

        #region IInvokeWrapper Members

        public void BeforeInvoke( InvocationInfo info )
        {
        }

        public object DoInvoke( InvocationInfo info )
        {
            T instance = _target.Instance;
            if ( _target.IsAlive )
            {
                return info.TargetMethod.Invoke( instance, info.Arguments );
            }
            throw new InvalidOperationException();
        }

        public void AfterInvoke( InvocationInfo info, object returnValue )
        {
        }

        #endregion
    }

This is a much more elegant approach and requires very little work to set up a full interface proxy around the weak reference for each service we want to wrap. Finally, we can test the code out to make sure our assumptions are working correctly.

    internal class Program
    {
        private static void Main( string[] args )
        {
            LinFu();
            ManualProxy();
            Console.ReadLine();
        }

        public static void LinFu()
        {
            var foo = new Foo();
            var weakReference = new Weak<WeakInterceptor<IFoo>>(
                new WeakInterceptor<IFoo>;(
                    new Weak<IFoo>( foo ) ) );
            var proxyFactory = new ProxyFactory();
            var baz = new Baz( proxyFactory.CreateProxy<IFoo>( weakReference.Instance ) );

            Verify( foo, weakReference, baz );
        }

        private static void ManualProxy()
        {
            var foo = new Foo();
            var weakReference = new Weak<WeekFoo>( new WeekFoo( foo ) );
            var baz = new Baz( weakReference.Target as IFoo );

            Verify( foo, weakReference, baz );
        }

        private static void Verify( Foo foo, WeakReference weakReference, Baz baz )
        {
            baz.Action();
            GC.Collect();

            Debug.Assert( weakReference.IsAlive );
            baz.Release();
            GC.Collect();

            Debug.Assert( weakReference.IsAlive == false );
            foo.Dispose();
            Debug.Assert( foo.IsDisposed );
        }
    }

We now have two methods for handing out weak service references to clients and allowing us to control the lifetime of the services for pooling, disposal, or whatever else we want to do without the client having to deal with the details. This is just a basic example. You can easily extend this into a service factory/container and track the instances you hand out.