Updates after resharper inspection.

Author: Oren (electricessence)

benchmarking/Open.Disposable.ObjectPools.Benchmarking.csproj

@@ -7,6 +7,14 @@
     <Version>1.0.0</Version>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
   <ItemGroup>
     <Compile Remove="OldTest.cs" />
   </ItemGroup>

benchmarking/Program.cs

@@ -39,14 +39,14 @@ static void Main(string[] args)
 			count => () => OptimisticArrayObjectPool.Create<object>((int)count * 2));
 
 		// Is ineveitably slower than the above but should be enabled for testing code changes.
-		//report.AddBenchmark("InterlockedArrayObjectPool",
-		//	count => () => InterlockedArrayObjectPool.Create<object>((int)count * 2));
+		report.AddBenchmark("InterlockedArrayObjectPool",
+			count => () => InterlockedArrayObjectPool.Create<object>((int)count * 2));
 
 		report.Pretest(200, 200); // Run once through first to scramble/warm-up initial conditions.
 
 		Console.SetCursorPosition(0, Console.CursorTop);
 
-		const int loopMultiple = 2;
+		const int loopMultiple = 6;
 		report.Test(4, 8 * loopMultiple);
 		report.Test(10, 8 * loopMultiple);
 		report.Test(50, 12 * loopMultiple);

source/Array/InterlockedArrayObjectPool.cs

@@ -27,11 +27,11 @@ public InterlockedArrayObjectPool(Func<T> factory, int capacity = DEFAULT_CAPACI
 		protected ReferenceContainer<T>[] Pool;
 
 		// Sets a limit on what has been stored yet to prevent over searching the array unnecessarily.. 
-		protected int MaxStored = 0;
+		protected int MaxStored;
 		protected const int MaxStoredIncrement = 5; // Instead of every one.
 
 		public override int Count
-			=> Pool.Count(e => e.Value != null)	+ PocketCount;
+			=> Pool.Count(e => e.Value != null) + PocketCount;
 
 		protected virtual bool Store(ReferenceContainer<T>[] p, T item, int index)
 			=> p[index].TrySave(item);
@@ -41,7 +41,7 @@ protected override bool Receive(T item)
 			var elements = Pool;
 			var len = elements?.Length ?? 0;
 
-			for (int i = 0; i < len; i++)
+			for (var i = 0; i < len; i++)
 			{
 				if (Store(elements, item, i))
 				{
@@ -62,7 +62,7 @@ protected override T TryRelease()
 			if (elements == null) return null;
 
 			var len = elements.Length;
-			for (int i = 0; i < MaxStored && i < len; i++)
+			for (var i = 0; i < MaxStored && i < len; i++)
 			{
 				var item = elements[i].TryRetrieve();
 				if (item != null) return item;

source/Collection/CollectionWrapperObjectPool.cs

@@ -41,16 +41,14 @@ protected override T TryRelease()
 
 			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.
+			if (item == null) return 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;
-			}
+			bool wasRemoved;
+			lock (p) wasRemoved = p.Remove(item);
+			if (!wasRemoved) goto retry;
 
 			return item;
 		}

source/Collection/ConcurrentQueueObjectPool.cs

@@ -35,7 +35,7 @@ protected override T TryRelease()
 		{
 			var p = Pool;
 			if (p == null) return null;
-			p.TryDequeue(out T item);
+			p.TryDequeue(out var item);
 			return item;
 		}
 

source/Collection/ConcurrentStackObjectPool.cs

@@ -30,7 +30,7 @@ protected override T TryRelease()
 		{
 			var p = Pool;
 			if (p == null) return null;
-			p.TryPop(out T item);
+			p.TryPop(out var item);
 			return item;
 		}
 

source/IObjectPool.cs

@@ -21,7 +21,6 @@ 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>
@@ -52,26 +51,28 @@ public interface IObjectPool<T> : IDisposable
 		int Count { get; }
 	}
 
-	public static partial class ObjectPoolExtensions
+	public static class ObjectPoolExtensions
 	{
 		/// <summary>
 		/// Receives items and iteratively adds them to the pool.
 		/// WARNING: These items are considered 'dead' but resurrectable so be sure not to hold on to their reference.
 		/// </summary>
+		/// <param name="target">The pool to give to.</param>
 		/// <param name="items">The items to give up to the pool.</param>
 		public static void Give<T>(this IObjectPool<T> target, IEnumerable<T> items)
 			where T : class
 		{
-			if (items != null)
-				foreach (var i in items)
-					target.Give(i);
+			if (items == null) return;
+			foreach (var i in items)
+				target.Give(i);
 		}
 
 		/// <summary>
 		/// Receives items and iteratively adds them to the pool.
 		/// WARNING: These items are considered 'dead' but resurrectable so be sure not to hold on to their reference.
 		/// </summary>
-		/// <param name="item2">The first item to give up to the pool.</param>
+		/// <param name="target">The pool to give to.</param>
+		/// <param name="item1">The first item to give up to the pool.</param>
 		/// <param name="item2">The second item to give up to the pool.</param>
 		/// <param name="items">The remaining items to give up to the pool.</param>
 		public static void Give<T>(this IObjectPool<T> target, T item1, T item2, params T[] items)

source/IRecycler.cs

@@ -3,7 +3,7 @@
 
 namespace Open.Disposable
 {
-	interface IRecycler<T> : IDisposable
+	interface IRecycler<in T> : IDisposable
 		where T : class
 	{
 		bool Recycle(T item);

source/ObjectPoolAutoTrimmer.cs

@@ -1,8 +1,10 @@
 using Open.Threading.Tasks;
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Open.Disposable
 {
+	[SuppressMessage("ReSharper", "FieldCanBeMadeReadOnly.Local")]
 	public class ObjectPoolAutoTrimmer : DisposableBase
 	{
 		ITrimmableObjectPool _pool;
@@ -15,11 +17,13 @@ public class ObjectPoolAutoTrimmer : DisposableBase
 		/// <summary>
 		///  Max size that trimming will allow.
 		/// </summary>
+		// ReSharper disable once NotAccessedField.Global
 		public readonly ushort TrimmedSize;
 
 		/// <summary>
 		/// Time to wait/defer trimming. Default is 500 milliSeconds.
 		/// </summary>
+		// ReSharper disable once NotAccessedField.Global
 		public readonly TimeSpan TrimDelay;
 
 		/// <summary>

source/ObjectPoolBase.cs

@@ -20,14 +20,15 @@ protected ObjectPoolBase(Func<T> factory, Action<T> recycler, Action<T> disposer
 		protected int MaxSize;
 		public int Capacity => MaxSize;
 
+		/// <inheritdoc />
 		/// <summary>
 		/// Total number of items in the pool.
 		/// </summary>
 		public abstract int Count { get; }
-		protected virtual int PocketCount => Pocket.Value == null ? 0 : 1;
+		protected int PocketCount => Pocket.Value == null ? 0 : 1;
 
-		protected Action<T> Recycler; // Before entering the pool.
-		protected Action<T> OnDiscarded; // When not able to be used.
+		protected readonly Action<T> Recycler; // Before entering the pool.
+		protected readonly Action<T> OnDiscarded; // When not able to be used.
 
 
 		// Read-only because if Take() is called after disposal, this still facilitates returing an object.
@@ -36,14 +37,15 @@ protected ObjectPoolBase(Func<T> factory, Action<T> recycler, Action<T> disposer
 
 		public T Generate() => Factory();
 
+		// ReSharper disable once UnassignedField.Global
 		protected ReferenceContainer<T> Pocket; // Default struct constructs itself.
 
 		#region Receive (.Give(T item))
 		protected virtual bool CanReceive => true; // A default of true is acceptable, enabling the Recieve method to do the actual deciding. 
 
 		protected bool PrepareToReceive(T item)
 		{
-			if (item!=null && CanReceive)
+			if (item != null && CanReceive)
 			{
 				var r = Recycler;
 				if (r != null)
@@ -97,7 +99,7 @@ public bool TryTake(out T item)
 		protected virtual bool SaveToPocket(T item)
 			=> Pocket.TrySave(item);
 
-		protected virtual T TakeFromPocket()
+		protected T TakeFromPocket()
 			=> Pocket.TryRetrieve();
 
 
@@ -122,11 +124,9 @@ protected override void OnBeforeDispose()
 
 		protected override void OnDispose(bool calledExplicitly)
 		{
-			if (calledExplicitly && OnDiscarded != null)
-			{
-				T d;
-				while ((d = TryRelease()) != null) OnDiscarded(d);
-			}
+			if (!calledExplicitly || OnDiscarded == null) return;
+			T d;
+			while ((d = TryRelease()) != null) OnDiscarded(d);
 		}
 	}
 }