Updated for .NET Standard 2.1

Extended benchmarks.

Author: Oren (electricessence)

benchmarking/Benchmarks/CollectionBenchmark.cs

@@ -9,7 +9,7 @@ public class CollectionBenchmark<T> : BenchmarkBase<Func<ICollection<T>>>
 	{
 		public CollectionBenchmark(uint size, uint repeat, Func<ICollection<T>> factory, Func<int, T> itemFactory) : base(size, repeat, factory)
 		{
-			_items = Enumerable.Range(0, (int)TestSize).Select(itemFactory).ToArray();
+			_items = Enumerable.Range(0, (int)TestSize * 2).Select(itemFactory).ToArray();
 		}
 
 		protected readonly T[] _items;
@@ -40,6 +40,17 @@ protected override IEnumerable<TimedResult> TestOnceInternal()
 				}
 			});
 
+			if (c is IList<T> list)
+			{
+				yield return TimedResult.Measure("IList<T> Read Access", () =>
+				{
+					for (var i = 0; i < TestSize; i += 2)
+					{
+						var _ = list[i];
+					}
+				});
+			}
+
 			yield return TimedResult.Measure("Empty Backwards (.Remove(last))", () =>
 			{
 				for (var i = 0; i < TestSize; i++) c.Remove(_items[TestSize - i - 1]);

benchmarking/Benchmarks/CollectionParallelBenchmark.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Threading.Tasks;
 
 namespace Open.Collections
@@ -24,17 +25,56 @@ protected override IEnumerable<TimedResult> TestOnceInternal()
 				Parallel.For(0, TestSize, i => c.Add(_items[i]));
 			});
 
+			yield return TimedResult.Measure("Enumerate", () =>
+			{
+				// ReSharper disable once NotAccessedVariable
+				var x = 0;
+				// ReSharper disable once LoopCanBeConvertedToQuery
+				foreach (var _ in c) { x++; }
+			});
+
 			// It's obvious to note that you have to 'lock' a collection or acquire a 'snapshot' before enumerating.
-			//yield return TimedResult.Measure("Enumerate", () =>
-			//{
-			//	Parallel.ForEach(c, i => { });
-			//});
+			yield return TimedResult.Measure("Enumerate (In Parallel)", () =>
+			{
+				Parallel.ForEach(c, i => { });
+			});
 
 			yield return TimedResult.Measure(".Contains(item) (In Parallel)", () =>
 			{
-				Parallel.For(0, TestSize, i => { var _ = c.Contains(_items[i]); });
+				Parallel.For(0, TestSize * 2, i => { var _ = c.Contains(_items[i]); });
 			});
 
+			if (c is IList<T> list)
+			{
+				yield return TimedResult.Measure("IList<T> Read Access", () =>
+				{
+					for (var i = 0; i < TestSize; i += 2)
+					{
+						var _ = list[i];
+					}
+				});
+
+				yield return TimedResult.Measure("IList<T> Read Access (In Parallel)", () =>
+				{
+					Parallel.For(0, (int)TestSize, i => { var _ = list[i]; });
+				});
+			}
+
+			if (c is ISynchronizedCollection<T> syncList)
+			{
+				yield return TimedResult.Measure(".Snapshot()", () =>
+				{
+					var _ = syncList.Snapshot();
+				});
+			}
+			else
+			{
+				yield return TimedResult.Measure(".Snapshot()", () =>
+				{
+					var _ = c.ToArray();
+				});
+			}
+
 			yield return TimedResult.Measure("Empty Backwards (.Remove(last)) (In Parallel)", () =>
 			{
 				Parallel.For(0, TestSize, i => { c.Remove(_items[TestSize - i - 1]); });

source/Open.Collections.csproj

@@ -15,9 +15,9 @@ Part of the "Open" set of libraries.</Description>
     <PackageProjectUrl>https://github.com/electricessence/Open.Collections/</PackageProjectUrl>
     <RepositoryUrl>https://github.com/electricessence/Open.Collections/</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <Version>2.6.0</Version>
-    <AssemblyVersion>2.6.0.0</AssemblyVersion>
-    <FileVersion>2.6.0.0</FileVersion>
+    <Version>2.6.1</Version>
+    <AssemblyVersion>2.6.1.0</AssemblyVersion>
+    <FileVersion>2.6.1.0</FileVersion>
     <PackageReleaseNotes></PackageReleaseNotes>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>

source/Queue/IQueue.cs

@@ -2,7 +2,6 @@
 
 namespace Open.Collections
 {
-	[SuppressMessage("ReSharper", "UnusedMemberInSuper.Global")]
 	public interface IQueue<T>
 	{
 		/// <inheritdoc cref="System.Collections.Generic.Queue&lt;T&gt;"/>

source/Queue/Queue.Concurrent.cs

@@ -6,11 +6,13 @@ public static partial class Queue
 	{
 		public class Concurrent<T> : ConcurrentQueue<T>, IQueue<T>
 		{
+#if NETSTANDARD2_0
 			/// <inheritdoc />
 			public void Clear()
 			{
 				while (TryDequeue(out _)) { }
 			}
+#endif
 		}
 	}
 }

source/Queue/Queue.Standard.cs

@@ -16,6 +16,7 @@ public Standard(IEnumerable<T> initial) : base(initial)
 
 			}
 
+#if NETSTANDARD2_0
 			/// <inheritdoc />
 			public virtual bool TryDequeue(out T item)
 			{
@@ -31,6 +32,17 @@ public virtual bool TryPeek(out T item)
 				item = ok ? Peek() : default;
 				return ok;
 			}
+#else
+			/// <inheritdoc />
+			public new virtual bool TryDequeue(out T item)
+				=> base.TryDequeue(out item);
+
+			/// <inheritdoc />
+			public new virtual bool TryPeek(out T item)
+				=> base.TryPeek(out item);
+#endif
+
+
 		}
 	}
 }

source/ReadOnlyCollectionWrapper.cs

@@ -2,7 +2,6 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Threading;
 
 namespace Open.Collections
 {

source/Synchronized/Readme.md

@@ -1,24 +1,25 @@
-# Synchronized Classes
+# Synchronized Collections
 
 Keeping in mind that without an exclusive lock of some kind, the data can change from one operation to the next.
 
 These classes are provided to help with simple operations that don't rely on lengthy exclusive locking.
 
 Some methods are available that assist with exclusive access:
 
-* ```.IfContains(item, action)```
-* ```.IfNotContains(item, action)```
-* ```.Snapshot()```
-* ```.ForEach(action, useSnapshot)```
-* ```.Export(destination)```
-* ```.CopyTo(array, arrayIndex)```
-* ```.Modify(action)```
+* `.IfContains(item, action)`
+* `.IfNotContains(item, action)`
+* `.Snapshot()`
+* `.ForEach(action, useSnapshot)`
+* `.Export(destination)`
+* `.CopyTo(array, arrayIndex)`
+* `.Modify(action)`
 
-A snapshot is simply a copy of the collection at a given moment that can then be operated on while the underlying collection can continute to mutate.
+A "snapshot" is simply a copy of the collection at a given moment that can then be operated on while the underlying collection can continue to mutate.
 
 ### Reads
 
-Any operation that the collection cannot be changing (adding/removing) while executing. ie. ```.Contains(item)```
+Any operation that the collection cannot be changing (adding/removing) while executing.  
+ie. ```.Contains(item)```
 
 ### Writes
 
@@ -32,14 +33,14 @@ Best to use these classes when expecting a mix of read/write but with a majority
 
 ## Read-Write Synchronized
 
-These classes use a ReaderWriterLockSlim to synchronize read-write access and can be faster in some specific cases.
+These classes use a `ReaderWriterLockSlim` to synchronize read-write access and can be faster in some specific cases.
 
-Best to use these classes when expecting a mix of read/write but with a majority of reads.
+Best to use these classes when expecting a mix of read/write but with a majority of reads and typically of a smaller size.
 
 ## Benchmarks
 
 *Important Observations:*
 
 * Be sure to benchmark the 'Release' configuration as the difference in performance versus 'Debug' can be dramatic.
 * Observe results on different machines with different core counts.
-* As collection sizes increase, performance behavior changes.  For example, for smaller collection sizes (~1000 or less) Read-Write synchronization wins most of the time.  But larger than that, a 'lock' for writes begins to out perform.
+* As collection sizes increase, performance behavior changes.  For example, for smaller collection sizes (~1000 or less) Read-Write synchronization wins most of the time.  But larger than that, a 'lock' for writes begins to out perform.