PoolableLifestyleManager
Manages a pool of objects.
using Castle.Core.Internal;
using Castle.MicroKernel.Context;
using Castle.MicroKernel.Lifestyle.Pool;
using Castle.MicroKernel.Registration;
using System;
namespace Castle.MicroKernel.Lifestyle
{
[Serializable]
public class PoolableLifestyleManager : AbstractLifestyleManager
{
private static readonly object poolFactoryLock = new object();
private readonly ThreadSafeInit init = new ThreadSafeInit();
private readonly int initialSize;
private readonly int maxSize;
private IPool pool;
protected IPool Pool {
get {
if (pool == null) {
bool flag = false;
try {
flag = init.ExecuteThreadSafeOnce();
if (pool == null)
pool = CreatePool(initialSize, maxSize);
return pool;
} finally {
if (flag)
init.EndThreadSafeOnceSection();
}
}
return pool;
}
}
public PoolableLifestyleManager(int initialSize, int maxSize)
{
this.initialSize = initialSize;
this.maxSize = maxSize;
}
public override void Dispose()
{
if (pool != null)
pool.Dispose();
}
public override bool Release(object instance)
{
if (pool != null)
return pool.Release(instance);
return false;
}
public override object Resolve(CreationContext context, IReleasePolicy releasePolicy)
{
return Pool.Request(context, (CreationContext c) => PoolCreationCallback(c, releasePolicy));
}
protected IPool CreatePool(int initialSize, int maxSize)
{
if (!base.Kernel.HasComponent(typeof(IPoolFactory))) {
lock (poolFactoryLock) {
if (!base.Kernel.HasComponent(typeof(IPoolFactory)))
base.Kernel.Register(Component.For<IPoolFactory>().ImplementedBy<DefaultPoolFactory>().NamedAutomatically("castle.internal-pool-factory"));
}
}
return base.Kernel.Resolve<IPoolFactory>().Create(initialSize, maxSize, base.ComponentActivator);
}
protected virtual Burden PoolCreationCallback(CreationContext context, IReleasePolicy releasePolicy)
{
Burden burden = base.CreateInstance(context, false);
Track(burden, releasePolicy);
return burden;
}
protected override void Track(Burden burden, IReleasePolicy releasePolicy)
{
burden.RequiresDecommission = true;
releasePolicy.Track(burden.Instance, burden);
}
}
}