Added recyclability to all pools.

Recycling only happens if an item can be recieved.

Author: Oren (electricessence)

source/BufferBlockObjectPool.cs

@@ -19,17 +19,27 @@ public class BufferBlockObjectPool<T> : TrimmableObjectPoolBase<T>
 		/// Constructs an ObjectPool that when .Take() is called will return the first possible item even if one is returned to the pool before the generator function completes.
 		/// </summary>
 		/// <param name="factory">The generator function that creates the items.</param>
+		/// <param name="recycler">The optional function that operates on an item just before entering the pool.</param>
 		/// <param name="maxSize">The maximum size of the object pool.  Default is ushort.MaxValue (65535).</param>
 		public BufferBlockObjectPool(
 			Func<T> factory,
-			int capacity = DEFAULT_CAPACITY) : base(factory, capacity)
+			Action<T> recycler,
+			int capacity = DEFAULT_CAPACITY)
+			: base(factory, recycler, capacity)
 		{
 			_pool = new BufferBlock<T>(new DataflowBlockOptions()
 			{
 				BoundedCapacity = capacity
 			});
 		}
 
+		public BufferBlockObjectPool(
+			Func<T> factory,
+			int capacity = DEFAULT_CAPACITY)
+			: this(factory, null, capacity)
+		{
+		}
+
 		protected BufferBlock<T> _pool;
 
 		Task<bool> Generate(out Task<T> actual)
@@ -102,27 +112,17 @@ public override sealed T Take()
 
 		protected override void OnDispose(bool calledExplicitly)
 		{
-			var pool = Nullify(ref _pool);
-			if (pool != null)
-			{
-				pool.Complete(); // No more... You're done...
-				if(pool.TryReceiveAll(out IList<T> items)) // Empty out...
-					items.Clear();
-			}
+			Nullify(ref _pool)?.Complete();
 		}
 
 		protected override bool GiveInternal(T item)
 		{
-			return (item == null ? null : _pool)
-				?.Post(item)
-				?? false;
+			return _pool.Post(item);
 		}
 
 		protected override Task<bool> GiveInternalAsync(T item)
 		{
-			return (item == null ? null : _pool)
-				?.SendAsync(item)
-				?? Task.FromResult(false);
+			return _pool.SendAsync(item);
 		}
 
 	}

source/CollectionWrapperObjectPool.cs

@@ -10,28 +10,30 @@ public class CollectionWrapperObjectPool<T, TCollection> : TrimmableObjectPoolBa
 		where T : class
 		where TCollection : class, ICollection<T>
 	{
-		public CollectionWrapperObjectPool(TCollection pool, Func<T> factory, int capacity = DEFAULT_CAPACITY) : base(factory, capacity)
+		public CollectionWrapperObjectPool(TCollection pool, Func<T> factory, Action<T> recycler, int capacity = DEFAULT_CAPACITY)
+			: base(factory, recycler, capacity)
 		{
 			Pool = pool;
 		}
 
+		public CollectionWrapperObjectPool(TCollection pool, Func<T> factory, int capacity = DEFAULT_CAPACITY)
+			: this(pool, factory, null, capacity)
+		{
+		}
+
 		protected TCollection Pool;
 
 		public override int Count => Pool?.Count ?? 0;
 
 		protected override bool GiveInternal(T item)
 		{
-			if (item != null)
+			lock (Pool)
 			{
-				var p = Pool;
-				if (p != null && p.Count < MaxSize)
-				{
-					lock (p) p.Add(item); // It's possible that the count could exceed MaxSize here, but the risk is negligble as a few over the limit won't hurt.
-					return true;
-				}
+				if (Count >= MaxSize) return false;
+				Pool.Add(item);
 			}
 
-			return false;
+			return true;
 		}
 
 		protected override T TryTakeInternal()
@@ -56,7 +58,7 @@ protected override T TryTakeInternal()
 
 		protected override void OnDispose(bool calledExplicitly)
 		{
-			Nullify(ref Pool)?.Clear();
+			Pool = null;
 		}
 	}
 

source/ConcurrentBagObjectPool.cs

@@ -10,28 +10,26 @@ public sealed class ConcurrentBagObjectPool<T> : TrimmableObjectPoolBase<T>
 		where T : class
 
 	{
-		public ConcurrentBagObjectPool(Func<T> factory, int capacity = DEFAULT_CAPACITY) : base(factory, capacity)
+
+		public ConcurrentBagObjectPool(Func<T> factory, Action<T> recycler, int capacity = DEFAULT_CAPACITY)
+			: base(factory, recycler, capacity)
 		{
 			Pool = new ConcurrentBag<T>();
 		}
 
+		public ConcurrentBagObjectPool(Func<T> factory, int capacity = DEFAULT_CAPACITY)
+			: this(factory, null, capacity)
+		{
+		}
+
 		ConcurrentBag<T> Pool;
 
 		public override int Count => Pool?.Count ?? 0;
 
 		protected override bool GiveInternal(T item)
 		{
-			if (item != null)
-			{
-				var p = Pool;
-				if (p != null && p.Count < MaxSize)
-				{
-					p.Add(item); // It's possible that the count could exceed MaxSize here, but the risk is negligble as a few over the limit won't hurt.
-					return true;
-				}
-			}
-
-			return false;
+			Pool.Add(item); // It's possible that the count could exceed MaxSize here, but the risk is negligble as a few over the limit won't hurt.
+			return true;
 		}
 
 		protected override T TryTakeInternal()

source/IObjectPool.cs

@@ -23,13 +23,15 @@ public interface IObjectPool<T> : IDisposable
 		/// WARNING: The item is considered 'dead' but resurrectable so be sure not to hold on to the item's reference.
 		/// </summary>
 		/// <param name="item">The item to give up to the pool.</param>
+		/// <param name="recycler">An optional action exectue on the item only if it's possible to return to the pool.</param>
 		void Give(T item);
 
 		/// <summary>
 		/// Asynchronously receives an item and adds it to the pool. Ignores null references.
 		/// WARNING: The item is considered 'dead' but resurrectable so be sure not to hold on to the item's reference.
 		/// </summary>
 		/// <param name="item">The item to give up to the pool.</param>
+		/// <param name="recycler">An optional action exectue on the item only if it's possible to return to the pool.</param>
 		Task GiveAsync(T item);
 
 		/// <summary>

source/LinkedListObjectPool.cs

@@ -7,10 +7,17 @@ namespace Open.Disposable
 	public class LinkedListObjectPool<T> : CollectionWrapperObjectPool<T, LinkedList<T>>
 		where T : class
 	{
-		public LinkedListObjectPool(Func<T> factory, int capacity = DEFAULT_CAPACITY) : base(new LinkedList<T>(), factory, capacity)
+		public LinkedListObjectPool(Func<T> factory, Action<T> recycler, int capacity = DEFAULT_CAPACITY)
+			: base(new LinkedList<T>(), factory, recycler, capacity)
 		{
 		}
 
+		public LinkedListObjectPool(Func<T> factory, int capacity = DEFAULT_CAPACITY)
+			: this(factory, null, capacity)
+		{
+		}
+
+
 		protected override T TryTakeInternal()
 		{
 			var p = Pool;

source/ObjectPoolAutoTrimmer.cs

@@ -28,25 +28,25 @@ public class ObjectPoolAutoTrimmer : DisposableBase
 		/// <summary>
 		/// Constructs an auto-trimming ObjectPool helper.
 		/// </summary>
-		/// <param name="target">The governable object pool to maintain.</param>
+		/// <param name="pool">The governable object pool to maintain.</param>
 		/// <param name="trimmedSize">The target size to limit to after a half second timeout.  Allowing the pool to still grow to the max size until the trim occurs.</param>
 		/// <param name="trimDelay">The amount of time to wait/defer trimming.</param>
 		public ObjectPoolAutoTrimmer(
 			ushort trimmedSize,
-			ITrimmableObjectPool target,
+			ITrimmableObjectPool pool,
 			TimeSpan? trimDelay = null)
 		{
-			_pool = target;
-			if (target is DisposableBase pool)
-				pool.BeforeDispose += Pool_BeforeDispose;
+			_pool = pool ?? throw new ArgumentNullException("pool");
+			if (pool is DisposableBase d)
+				d.BeforeDispose += Pool_BeforeDispose;
 
 			TrimmedSize = _trimmedSize = trimmedSize;
 			TrimDelay = _trimDelay = trimDelay ?? TimeSpan.FromMilliseconds(500);
 
 			_trimmer = new ActionRunner(TrimInternal);
 
-			target.GivenTo += Target_GivenTo;
-			target.TakenFrom += Target_TakenFrom;
+			pool.GivenTo += Target_GivenTo;
+			pool.TakenFrom += Target_TakenFrom;
 
 		}
 

source/ObjectPoolBase.cs

@@ -10,15 +10,22 @@ public abstract class ObjectPoolBase<T> : DisposableBase, IObjectPool<T>
 	{
 		protected const int DEFAULT_CAPACITY = Constants.DEFAULT_CAPACITY;
 
-		protected ObjectPoolBase(Func<T> factory, int capacity = DEFAULT_CAPACITY)
+		protected ObjectPoolBase(Func<T> factory, Action<T> recycler, int capacity = DEFAULT_CAPACITY)
 		{
 			if (capacity < 1)
 				throw new ArgumentOutOfRangeException("capacity", capacity, "Must be at least 1.");
 			Factory = factory ?? throw new ArgumentNullException("factory");
 			MaxSize = capacity;
+			Recycler = recycler;
 		}
 
+		protected ObjectPoolBase(Func<T> factory, int capacity = DEFAULT_CAPACITY)
+			: this(factory, null, capacity)
+		{
+
+		}
 
+		protected Action<T> Recycler;
 		protected int MaxSize;
 		public int Capacity => MaxSize;
 
@@ -31,11 +38,14 @@ public T Generate()
 			return Factory();
 		}
 
+		protected abstract bool CanGive(T item);
+
+		// Contract should be that no item can be null here.
 		protected abstract bool GiveInternal(T item);
 
 		public virtual void Give(T item)
 		{
-			GiveInternal(item);
+			if(CanGive(item)) GiveInternal(item);
 		}
 
 		protected virtual Task<bool> GiveInternalAsync(T item)
@@ -45,6 +55,7 @@ protected virtual Task<bool> GiveInternalAsync(T item)
 
 		public virtual Task GiveAsync(T item)
 		{
+			if (item == null) return Task.FromResult(false);
 			return GiveInternalAsync(item);
 		}
 

source/OptimisticArrayObjectPool.cs

@@ -13,11 +13,20 @@ namespace Open.Disposable
 	public class OptimisticArrayObjectPool<T> : ObjectPoolBase<T>
 		where T : class
 	{
-		public OptimisticArrayObjectPool(Func<T> factory, int capacity = DEFAULT_CAPACITY) : base(factory, capacity)
+
+		public OptimisticArrayObjectPool(Func<T> factory, Action<T> recycler, int capacity = DEFAULT_CAPACITY)
+			: base(factory, recycler, capacity)
 		{
 			_pool = new Element[capacity - 1];
 		}
 
+		public OptimisticArrayObjectPool(Func<T> factory, int capacity = DEFAULT_CAPACITY)
+			: this(factory, null, capacity)
+		{
+		}
+
+
+
 		[DebuggerDisplay("{Value,nq}")]
 		private struct Element
 		{
@@ -27,10 +36,18 @@ private struct Element
 		Element[] _pool;
 		T _firstItem;
 
-		protected override bool GiveInternal(T item)
+		protected override bool CanGive(T item)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override void Give(T item)
 		{
-			if (item == null) return false;
+			GiveInternal(item);
+		}
 
+		protected override bool GiveInternal(T item)
+		{
 			// First see if optimisically we can store in _firstItem;
 			if (_firstItem == null)
 			{
@@ -88,13 +105,11 @@ protected override T TryTakeInternal()
 
 		protected override void OnDispose(bool calledExplicitly)
 		{
+			_pool = null;
 			_firstItem = null;
-			var pool = Nullify(ref _pool);
-			var len = pool?.Length ?? 0;
-
-			for (var i = 0; i < len; i++)
-				pool[i].Value = null;
 		}
+
+
 	}
 
 	public static class OptimisticArrayObjectPool

source/QueueObjectPool.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Open.Disposable
+{
+	public sealed class QueueObjectPool<T> : TrimmableObjectPoolBase<T>
+		where T : class
+	{
+
+		public QueueObjectPool(Func<T> factory, Action<T> recycler, int capacity = DEFAULT_CAPACITY)
+			: base(factory, recycler, capacity)
+		{
+			Pool = new Queue<T>(capacity); // Very very slight speed improvment when capacity is set.
+		}
+
+		public QueueObjectPool(Func<T> factory, int capacity = DEFAULT_CAPACITY)
+			: this(factory, null, capacity)
+		{
+			
+		}
+
+		Queue<T> Pool;
+
+		public override int Count => Pool?.Count ?? 0;
+
+		protected override bool GiveInternal(T item)
+		{
+			if (Count < MaxSize)
+			{
+				lock (Pool) Pool.Enqueue(item); // It's possible that the count could exceed MaxSize here, but the risk is negligble as a few over the limit won't hurt.
+				return true;
+			}
+
+			return false;
+		}
+
+		protected override T TryTakeInternal()
+		{
+			var p = Pool;
+			if (p!=null && p.Count != 0)
+			{
+				lock (p)
+				{
+					if (p.Count!=0)
+						return p.Dequeue();
+				}
+
+			}
+
+			return null;
+		}
+
+		protected override void OnDispose(bool calledExplicitly)
+		{
+			Pool = null;
+		}
+	}
+
+	public static class QueueObjectPool
+	{
+		public static QueueObjectPool<T> Create<T>(Func<T> factory, int capacity = Constants.DEFAULT_CAPACITY)
+			where T : class
+		{
+			return new QueueObjectPool<T>(factory, capacity);
+		}
+
+		public static QueueObjectPool<T> Create<T>(int capacity = Constants.DEFAULT_CAPACITY)
+			where T : class, new()
+		{
+			return Create(() => new T(), capacity);
+		}
+	}
+}