Updated ObjectPool impementions.

Author: Oren (electricessence)

Open.Disposable.ObjectPools.Tests/ObjectPoolBenchmarks.cs

@@ -0,0 +1,86 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Threading.Tasks.Dataflow;
+
+namespace Open.Disposable
+{
+	[TestClass]
+	public class ObjectPoolBenchmarks
+	{
+		const int TEST_COUNT = 200;
+		const int TEST_LOOPS = 1000;
+
+		static void Benchmark<T>(IObjectPool<T> pool)
+			where T : class
+		{
+			var tank = new ConcurrentBag<T>(); // This will have an effect on performance measurement, but hopefully consistently.
+			int remaining = 0;
+			using (pool)
+			{
+				Parallel.For(0, TEST_COUNT, i => tank.Add(pool.Take()));
+
+				Parallel.ForEach(tank, e => pool.Give(e));
+
+				while (pool.TryTake() != null) { remaining++; }
+			}
+			//Console.WriteLine("Remaining: {0}", remaining);
+			Assert.IsTrue(remaining!=0);
+		}
+
+		static void Benchmark<T>(IEnumerable<IObjectPool<T>> pools)
+			where T : class
+		{
+			foreach (var p in pools)
+				Benchmark(p);
+		}
+
+		OptimisticArrayObjectPool<object>[] OptimisticArrayObjectPools
+			= Enumerable.Range(0, TEST_LOOPS)
+			.Select(i => OptimisticArrayObjectPool.Create<object>(TEST_COUNT * 2))
+			.ToArray();
+
+		[TestMethod]
+		public void OptimisticArrayObjectPool_Benchmark()
+		{
+			Benchmark(OptimisticArrayObjectPools);
+		}
+
+		ConcurrentBagObjectPool<object>[] ConcurrentBagObjectPools
+			= Enumerable.Range(0, TEST_LOOPS)
+			.Select(i => ConcurrentBagObjectPool.Create<object>(TEST_COUNT * 2))
+			.ToArray();
+
+		[TestMethod]
+		public void ConcurrentBagObjectPool_Benchmark()
+		{
+			Benchmark(ConcurrentBagObjectPools);
+		}
+
+		BufferBlockObjectPool<object>[] BufferBlockObjectPools
+			= Enumerable.Range(0, TEST_LOOPS)
+			.Select(i => BufferBlockObjectPool.Create<object>(TEST_COUNT * 2))
+			.ToArray();
+
+		[TestMethod]
+		public void BufferBlockObjectPool_Benchmark()
+		{
+			Benchmark(BufferBlockObjectPools);
+		}
+
+
+		LinkedListObjectPool<object>[] LinkedListObjectPools
+			= Enumerable.Range(0, TEST_LOOPS)
+			.Select(i => LinkedListObjectPool.Create<object>(TEST_COUNT * 2))
+			.ToArray();
+
+		[TestMethod]
+		public void LinkedListObjectPool_Benchmark()
+		{
+			Benchmark(LinkedListObjectPools);
+		}
+	}
+}

Open.Disposable.ObjectPools.Tests/ObjectPoolSmokeTests.cs

@@ -0,0 +1,45 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Open.Disposable
+{
+	[TestClass]
+	public class ObjectPoolSmokeTests
+	{
+		class IdContainer
+		{
+			public int ID;
+		}
+
+        [TestMethod]
+        public void BufferBlockObjectPool_FactoryTest()
+        {
+			int i = 0;
+			var pool = BufferBlockObjectPool.Create(()=>new IdContainer { ID = ++i });
+			Assert.AreEqual(1, pool.Take().ID);
+		}
+
+		[TestMethod]
+		public void ConcurrentBagObjectPool_FactoryTest()
+		{
+			int i = 0;
+			var pool = ConcurrentBagObjectPool.Create(() => new IdContainer { ID = ++i });
+			Assert.AreEqual(1, pool.Take().ID);
+		}
+
+		[TestMethod]
+		public void OptimisticArrayObjectPool_FactoryTest()
+		{
+			int i = 0;
+			var pool = OptimisticArrayObjectPool.Create(() => new IdContainer { ID = ++i });
+			Assert.AreEqual(1, pool.Take().ID);
+		}
+
+		[TestMethod]
+		public void LinkedListObjectPool_FactoryTest()
+		{
+			int i = 0;
+			var pool = LinkedListObjectPool.Create(() => new IdContainer { ID = ++i });
+			Assert.AreEqual(1, pool.Take().ID);
+		}
+	}
+}

Open.Disposable.ObjectPools.Tests/Open.Disposable.ObjectPools.Tests.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>    
+    <TargetFramework>netcoreapp1.1</TargetFramework>    
+    <RootNamespace>Open.Disposable</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="1.1.11" />
+    <PackageReference Include="MSTest.TestFramework" Version="1.1.11" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\source\Open.Disposable.ObjectPools.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
+</Project>

source/BufferBlockObjectPool.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Threading.Tasks.Dataflow;
+
+namespace Open.Disposable
+{
+	/// <summary>
+	/// 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>
+	/// <typeparam name="T">The reference type contained.</typeparam>
+	[DebuggerDisplay("Count = {Count}")]
+	public class BufferBlockObjectPool<T> : TrimmableObjectPoolBase<T>
+		where T : class
+	{
+		/// <summary>
+		/// 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="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)
+		{
+			_pool = new BufferBlock<T>(new DataflowBlockOptions()
+			{
+				BoundedCapacity = capacity
+			});
+		}
+
+		protected BufferBlock<T> _pool;
+
+		Task<bool> Generate(out Task<T> actual)
+		{
+			actual = Task.Run(Factory);
+			return actual.ContinueWith(t =>
+				t.Status == TaskStatus.RanToCompletion && (_pool?.Post(t.Result) ?? false) // .Post is synchronous but should return immediately if bounded capacity is met.
+			);
+		}
+
+		public override int Count => _pool?.Count ?? 0;
+
+		protected override sealed T TryTakeInternal()
+		{
+			var p = _pool;
+			if (p == null) return null;
+			p.TryReceive(out T item);
+			return item;
+		}
+
+		protected override async Task<T> TakeAsyncInternal()
+		{
+			CancellationTokenSource ts = null; // If something goes wrong we need a way to cancel.
+			var taken = _pool?.ReceiveAsync((ts = new CancellationTokenSource()).Token);
+			if (taken != null)
+			{
+				while (taken.Status != TaskStatus.RanToCompletion)
+				{
+					// Ok we need to push into the pool...
+					var generated = Generate(out Task<T> actual);
+
+					if (await Task.WhenAny(taken, generated) == generated && !generated.Result)
+					{
+						// ^^^ Not received yet and was not added to pool? Uh-oh...
+						ts.Cancel(); // Since the generator failed or was unable to be added, then cancel waiting to recieve it.
+
+						// Was it actually cancelled? 
+						if (await taken.ContinueWith(t => t.IsCanceled)) // || t.IsFaulted ... .ReceiveAsync should never fault.
+						{
+							if (actual.IsFaulted)
+								throw actual.Exception; // Possible generator failure.
+							if (actual.Status == TaskStatus.RanToCompletion)
+								return actual.Result; // Don't let it go to waste.
+
+							// This is a rare edge case where there's no fault but did not complete.  Effectively erroneous.
+							Debug.Fail("Somehow the generate task did not complete and had no fault.");
+							return base.Take();
+						}
+					}
+				}
+
+				OnTakenFrom();
+				return taken.Result;
+			}
+
+			return base.Take(); // Pool is closed/completed.  Just do this here without queueing.
+		}
+
+		public override sealed T Take()
+		{
+			// See if there's one available already.
+			if (TryTake(out T firstTry))
+				return firstTry;
+
+			if (_pool == null)
+				return Factory();
+
+			return TakeAsync().Result;
+		}
+
+		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();
+			}
+		}
+
+		protected override bool GiveInternal(T item)
+		{
+			return (item == null ? null : _pool)
+				?.Post(item)
+				?? false;
+		}
+
+		protected override Task<bool> GiveInternalAsync(T item)
+		{
+			return (item == null ? null : _pool)
+				?.SendAsync(item)
+				?? Task.FromResult(false);
+		}
+
+	}
+
+	public static class BufferBlockObjectPool
+	{
+		public static BufferBlockObjectPool<T> Create<T>(Func<T> factory, int capacity = Constants.DEFAULT_CAPACITY)
+			where T : class
+		{
+			return new BufferBlockObjectPool<T>(factory, capacity);
+		}
+
+		public static BufferBlockObjectPool<T> Create<T>(int capacity = Constants.DEFAULT_CAPACITY)
+			where T : class, new()
+		{
+			return Create(() => new T(), capacity);
+		}
+	}
+}

source/CollectionWrapperObjectPool.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Open.Disposable
+{
+	public class CollectionWrapperObjectPool<T, TCollection> : TrimmableObjectPoolBase<T>
+		where T : class
+		where TCollection : class, ICollection<T>
+	{
+		public CollectionWrapperObjectPool(TCollection pool, Func<T> factory, int capacity = DEFAULT_CAPACITY) : base(factory, capacity)
+		{
+			Pool = pool;
+		}
+
+		protected TCollection 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)
+				{
+					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;
+				}
+			}
+
+			return false;
+		}
+
+		protected override T TryTakeInternal()
+		{
+			retry:
+
+			var p = Pool;
+			var item = p?.FirstOrDefault();
+			if (item != null)
+			{
+				/* Removing the first item is typically horribly inefficient but we can't make assumptions about the implementation here.
+				 * It's a trade off between potentially iterating the entire collection before removing the last item, or relying on the underlying implementation.
+				 * This implementation is in place for reference more than practice.  Sub classes should override. */
+
+				bool wasRemoved = false;
+				lock (p) wasRemoved = p.Remove(item);
+				if (!wasRemoved) goto retry;
+			}
+
+			return item;
+		}		
+
+		protected override void OnDispose(bool calledExplicitly)
+		{
+			Nullify(ref Pool)?.Clear();
+		}
+	}
+
+	public class CollectionWrapperObjectPool<T> : CollectionWrapperObjectPool<T, ICollection<T>>
+		where T : class
+	{
+		public CollectionWrapperObjectPool(ICollection<T> pool, Func<T> factory, int capacity = DEFAULT_CAPACITY) : base(pool, factory, capacity)
+		{
+		}
+	}
+}