Implement tests for reinitialise error event, fix bugs.

Remove unused code and clean up new code analysis warnings.

src/PoolSharp.Shared.ConcurrentBagImplementation/Pool.cs

@@ -32,7 +32,7 @@ public class Pool<T> : PoolBase<T>
 		private long _PoolInstancesCount;
 
 #if SUPPORTS_THREADS
-				System.Threading.Thread _ReinitialiseThread;
+		private readonly System.Threading.Thread _ReinitialiseThread;
 #endif
 
 		#endregion
@@ -53,9 +53,11 @@ public Pool(PoolPolicy<T> poolPolicy) : base(poolPolicy)
 			{
 				_ItemsToInitialise = new System.Collections.Concurrent.BlockingCollection<T>();
 #if SUPPORTS_THREADS
-				_ReinitialiseThread = new System.Threading.Thread(this.BackgroundReinitialise);
-				_ReinitialiseThread.Name = this.GetType().FullName + " Background Reinitialise";
-				_ReinitialiseThread.IsBackground = true;
+				_ReinitialiseThread = new System.Threading.Thread(this.BackgroundReinitialise)
+				{
+					Name = this.GetType().FullName + " Background Reinitialise",
+					IsBackground = true
+				};
 				_ReinitialiseThread.Start();
 #else
 				System.Threading.Tasks.Task.Factory.StartNew(this.BackgroundReinitialise, System.Threading.Tasks.TaskCreationOptions.LongRunning);
@@ -80,14 +82,16 @@ public override T Take()
 		{
 			CheckDisposed();
 
-			T retVal;
 
-			if (_Pool.TryTake(out retVal))
+			if (_Pool.TryTake(out var retVal))
 			{
 				Interlocked.Decrement(ref _PoolInstancesCount);
 
 				if (PoolPolicy.InitializationPolicy == PooledItemInitialization.Take && PoolPolicy.ReinitializeObject != null)
-					PoolPolicy.ReinitializeObject(retVal);
+				{
+					if (!ReinitialiseObject(retVal))
+						retVal = PoolPolicy.Factory(this);
+				}
 			}
 			else
 				retVal = PoolPolicy.Factory(this);
@@ -125,7 +129,9 @@ public override void Add(T value)
 				else
 				{
 					if (PoolPolicy.InitializationPolicy == PooledItemInitialization.Return && PoolPolicy.ReinitializeObject != null)
-						PoolPolicy.ReinitializeObject(value);
+					{
+						if (!ReinitialiseObject(value)) return;
+					}
 
 					_Pool.Add(value);
 					Interlocked.Increment(ref _PoolInstancesCount);
@@ -190,11 +196,9 @@ protected override void Dispose(bool disposing)
 
 				if (IsPooledTypeDisposable)
 				{
-					T item;
-
 					while (!_Pool.IsEmpty)
 					{
-						_Pool.TryTake(out item);
+						_Pool.TryTake(out var item);
 						SafeDispose(item);
 					}
 				}
@@ -207,7 +211,7 @@ protected override void Dispose(bool disposing)
 
 		private void BackgroundReinitialise()
 		{
-			T item = default(T);
+			T item = default;
 			while (!_ItemsToInitialise.IsCompleted)
 			{
 				try
@@ -225,19 +229,7 @@ private void BackgroundReinitialise()
 						SafeDispose(item);
 					else
 					{
-						try
-						{
-							if (PoolPolicy.ReinitializeObject != null)
-								PoolPolicy.ReinitializeObject(item);
-						}
-						catch (Exception ex)
-						{
-							OnReinitialiseError(new ReinitialiseErrorEventArgs<T>(ex, item));
-							SafeDispose(item);
-							item = default;
-						}
-
-						if (item != null && ShouldReturnToPool(item))
+						if (ReinitialiseObject(item) && ShouldReturnToPool(item))
 						{
 							_Pool.Add(item);
 
@@ -258,47 +250,19 @@ private void SafeAddToReinitialiseQueue(T pooledObject)
 			catch (InvalidOperationException) { } //Handle race condition on above if condition.
 		}
 
-		private void ProcessReturnedItems()
+		private bool ReinitialiseObject(T item)
 		{
-			//Only bother reinitialising items while we're alive.
-			//If we're shutdown, even with items left to process, then just ignore them.
-			//We're not going to use them anyway.
-			while (!_ItemsToInitialise.IsAddingCompleted)
-			{
-				ReinitialiseAndReturnToPoolOrDispose(_ItemsToInitialise.Take());
-			}
-
-			//If we're done but the there are disposable items in the queue,
-			//dispose each one.
-			if (!_ItemsToInitialise.IsCompleted && IsPooledTypeDisposable)
+			try
 			{
-				while (!_ItemsToInitialise.IsCompleted)
-				{
-					SafeDispose(_ItemsToInitialise.Take());
-				}
+				PoolPolicy.ReinitializeObject(item);
+				return true;
 			}
-		}
-
-		private void ReinitialiseAndReturnToPoolOrDispose(T value)
-		{
-			if (ShouldReturnToPool(value))
+			catch (Exception ex)
 			{
-				try
-				{
-					PoolPolicy.ReinitializeObject(value);
-				}
-				catch (Exception ex)
-				{
-					OnReinitialiseError(new ReinitialiseErrorEventArgs<T>(ex, value));
-					SafeDispose(value);
-					return;
-				}
-
-				_Pool.Add(value);
-				Interlocked.Increment(ref _PoolInstancesCount);
+				OnReinitialiseError(new ReinitialiseErrorEventArgs<T>(ex, item));
+				SafeDispose(item);
 			}
-			else
-				SafeDispose(value);
+			return false;
 		}
 
 		private bool ShouldReturnToPool(T pooledObject)

src/PoolSharp.Tests/PoolTests.cs

@@ -84,7 +84,7 @@ public void Pool_Take_ThrowsWhenPoolDisposed()
 		{
 			var pool = GetPool(1, PooledItemInitialization.Take);
 			pool.Dispose();
-			var item = pool.Take();
+			_ = pool.Take();
 		}
 
 		#endregion
@@ -367,6 +367,92 @@ public void PooledObject_Dispose_ReturnsToPool()
 
 		#endregion
 
+		#region Reinitialise Error Handling Tests
+
+		[TestMethod]
+		public void PooledObject_BackgroundReinitialise_RasisesEvent_OnReinitialiseError()
+		{
+			var policy = new PoolPolicy<PooledObject<DisposableTestPoolItem>>()
+			{
+				Factory = (p) => new PooledObject<DisposableTestPoolItem>(p, new DisposableTestPoolItem()),
+				InitializationPolicy = PooledItemInitialization.AsyncReturn,
+				MaximumPoolSize = 1,
+				ReinitializeObject = (item) =>
+				{
+					throw new OutOfMemoryException("Test");
+				}
+			};
+
+			var eventRaised = false;
+			using (var eventRaisedSignal = new System.Threading.ManualResetEvent(false))
+			{
+				var pool = new Pool<PooledObject<DisposableTestPoolItem>>(policy);
+				pool.ReinitialiseError += (s, e) => { eventRaised = true; eventRaisedSignal.Set(); };
+
+				var item = pool.Take();
+				pool.Add(item);
+				eventRaisedSignal.WaitOne(1000);
+				Assert.IsTrue(eventRaised);
+			}
+		}
+
+		[TestMethod]
+		public void PooledObject_ReinitialiseOnReturn_RasisesEvent_OnReinitialiseError()
+		{
+			var policy = new PoolPolicy<PooledObject<DisposableTestPoolItem>>()
+			{
+				Factory = (p) => new PooledObject<DisposableTestPoolItem>(p, new DisposableTestPoolItem()),
+				InitializationPolicy = PooledItemInitialization.Return,
+				MaximumPoolSize = 1,
+				ReinitializeObject = (item) =>
+				{
+					throw new OutOfMemoryException("Test");
+				}
+			};
+
+			var eventRaised = false;
+			using (var eventRaisedSignal = new System.Threading.ManualResetEvent(false))
+			{
+				var pool = new Pool<PooledObject<DisposableTestPoolItem>>(policy);
+				pool.ReinitialiseError += (s, e) => { eventRaised = true; eventRaisedSignal.Set(); };
+
+				var item = pool.Take();
+				pool.Add(item);
+				eventRaisedSignal.WaitOne(1000);
+				Assert.IsTrue(eventRaised);
+			}
+		}
+
+		[TestMethod]
+		public void PooledObject_ReinitialiseOnTake_RasisesEvent_OnReinitialiseError()
+		{
+			var policy = new PoolPolicy<PooledObject<DisposableTestPoolItem>>()
+			{
+				Factory = (p) => new PooledObject<DisposableTestPoolItem>(p, new DisposableTestPoolItem()),
+				InitializationPolicy = PooledItemInitialization.Take,
+				MaximumPoolSize = 1,
+				ReinitializeObject = (item) =>
+				{
+					throw new OutOfMemoryException("Test");
+				}
+			};
+
+			var eventRaised = false;
+			using (var eventRaisedSignal = new System.Threading.ManualResetEvent(false))
+			{
+				var pool = new Pool<PooledObject<DisposableTestPoolItem>>(policy);
+				pool.ReinitialiseError += (s, e) => { eventRaised = true; eventRaisedSignal.Set(); };
+
+				var item = pool.Take();
+				pool.Add(item);
+				item = pool.Take();
+				eventRaisedSignal.WaitOne(1000);
+				Assert.IsTrue(eventRaised);
+			}
+		}
+
+		#endregion
+
 		#region Private Methods
 
 		private IPool<TestPoolItem> GetPool()