Updated.

Author: Oren (electricessence)

Open.Threading.ReadWrite.csproj

@@ -1,25 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <RootNamespace>Open.Threading</RootNamespace>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Authors>electricessence</Authors>
     <Company />
     <Product />
-    <PackageLicenseUrl>https://github.com/electricessence/Open.Threading/blob/master/LISCENSE.md</PackageLicenseUrl>
+    <PackageLicenseUrl></PackageLicenseUrl>
     <Description>Useful set of extensions and classes for simplifying and optimizing read-write synchronization.
 
 Part of the "Open" set of libraries.</Description>
-    <Version>1.1.2</Version>
-    <AssemblyVersion>1.1.2.0</AssemblyVersion>
-    <FileVersion>1.1.2.0</FileVersion>
+    <Version>1.1.3</Version>
+    <AssemblyVersion>1.1.3.0</AssemblyVersion>
+    <FileVersion>1.1.3.0</FileVersion>
     <PackageTags>dotnet, dotnet-core, dotnetcore, cs, collections, extensions, threadsafe, thread-safe, readwrite, read-write, readerwriterlock, readerwriterlockslim</PackageTags>
     <Copyright>https://github.com/electricessence/Open.Threading/blob/master/LISCENSE.md</Copyright>
     <PackageProjectUrl>https://github.com/electricessence/Open.Threading/</PackageProjectUrl>
     <RepositoryUrl>https://github.com/electricessence/Open.Threading/</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageReleaseNotes></PackageReleaseNotes>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
@@ -38,9 +39,7 @@ Part of the "Open" set of libraries.</Description>
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Open.Diagnostics" Version="1.3.0" />
-    <PackageReference Include="Open.Disposable" Version="1.2.1" />
-    <PackageReference Include="Open.Disposable.ObjectPools" Version="2.1.3" />
+    <PackageReference Include="Open.Disposable.ObjectPools" Version="2.2.0" />
   </ItemGroup>
 
 </Project>

ReadWriteHelper.cs

@@ -3,7 +3,6 @@
  * Licensing: MIT https://github.com/electricessence/Open/blob/dotnet-core/LICENSE.md
  */
 
-using Open.Diagnostics;
 using Open.Disposable;
 using System;
 using System.Collections.Concurrent;
@@ -40,7 +39,7 @@ public ReaderWriterLockTracker(LockRecursionPolicy policy)
 
 			public bool Reserve(object context)
 			{
-				if (IsDisposed)
+				if (WasDisposed)
 					return false;
 
 				lock (_registry)
@@ -140,15 +139,15 @@ private ReaderWriterLockTracker GetLock(TKey key, LockType type, object context,
 			ReaderWriterLockSlimExensions.ValidateMillisecondsTimeout(millisecondsTimeout);
 			Contract.EndContractBlock();
 
-			if (IsDisposed)
+			if (WasDisposed)
 				return null;
 
 			// Need to be able to enter a lock before releasing access in order to prevent removal...
 			var r = CleanupManager.ReadValue(
 				() =>
 				{
 					// It is possible that a read could be acquired while disposing just before the dispose.
-					if (IsDisposed)
+					if (WasDisposed)
 						return null;
 
 					// Get a tracker...
@@ -161,21 +160,21 @@ private ReaderWriterLockTracker GetLock(TKey key, LockType type, object context,
 							result = Locks.GetOrAdd(key, k => created = LockPool.Take());
 						}
 						// Safeguard against rare case of when a disposed tracker is retained via an exception (possibly?). :(
-						while (!IsDisposed && result.IsDisposed);
+						while (!WasDisposed && result.WasDisposed);
 
 
 						// If the one created is not the one retrieved, go ahead and add it to the pool so it doesn't go to waste.
 						if (created != null && created != result)
 						{
-							if (IsDisposed)
+							if (WasDisposed)
 								created.Dispose();
 							else
 								LockPool.Give(created);
 						}
 
 						// This should never get out of sync, but just in case...
 						var rlock = result.Lock;
-						if (rlock == null || result.IsDisposed)
+						if (rlock == null || result.WasDisposed)
 						{
 							Debug.Fail("A lock tracker was retained after it was disposed.");
 							return null;
@@ -188,7 +187,7 @@ private ReaderWriterLockTracker GetLock(TKey key, LockType type, object context,
 					}
 
 					// Quick check to avoid further processes...
-					if (IsDisposed)
+					if (WasDisposed)
 						return null;
 
 					var lockHeld = false;
@@ -200,7 +199,7 @@ private ReaderWriterLockTracker GetLock(TKey key, LockType type, object context,
 					}
 					catch (LockRecursionException lrex)
 					{
-						lrex.WriteToDebug();
+						Debug.WriteLine(lrex.ToString());
 						Debugger.Break(); // Need to be able to track down source.
 						throw;
 					}
@@ -215,7 +214,7 @@ private ReaderWriterLockTracker GetLock(TKey key, LockType type, object context,
 
 			// In the rare case that a dispose could be initiated during this ReadValue:
 			// We need to not propagate locking...
-			if (r == null || !IsDisposed) return r;
+			if (r == null || !WasDisposed) return r;
 			ReleaseLock(r.Lock, type);
 			r.Clear(context);
 
@@ -268,7 +267,7 @@ private void ReleaseLock(ReaderWriterLockSlim target, LockType type)
 					break;
 			}
 
-			if (IsDisposed) return;
+			if (WasDisposed) return;
 			UpdateCleanupDelay();
 
 			//SetCleanup(CleanupMode.ImmediateSynchronous); 
@@ -307,7 +306,7 @@ private bool Execute(TKey key, LockType type, Action<ReaderWriterLockSlim> closu
 				}
 				catch (Exception ex)
 				{
-					ex.WriteToDebug();
+					Debug.WriteLine(ex.ToString());
 					// The above cannot fail or dire concequences...
 					Debugger.Break();
 					throw;
@@ -670,7 +669,7 @@ private void CleanupInternal()
 				if (!tempLock.CanDispose || !Locks.TryRemove(key, out tempLock) || tempLock == null) continue;
 
 #if DEBUG
-				if (tempLock.IsDisposed && !IsDisposed)
+				if (tempLock.WasDisposed && !WasDisposed)
 				{
 					// Possilby caused by an exception?
 					Debug.Fail("A tracker was disposed while in the lock registry.");
@@ -679,10 +678,10 @@ private void CleanupInternal()
 
 				//lock (tempLock)
 				//{
-				if (tempLock.IsDisposed) continue;
+				if (tempLock.WasDisposed) continue;
 				if (tempLock.CanDispose)
 				{
-					if (IsDisposed)
+					if (WasDisposed)
 					{
 						// Don't add back to the pool, just get rid of..
 						tempLock.Dispose();
@@ -709,7 +708,7 @@ private void CleanupInternal()
 		protected void UpdateCleanupDelay()
 		{
 			// This presents a maximum delay of 10 seconds and if the number of lock counts get's over 100 it will decrease the time before cleanup.
-			if (!IsDisposed)
+			if (!WasDisposed)
 				CleanupDelay = Math.Max(Math.Min(1000000 / (Locks.Count + 1), 10000), 1000); // Don't allow for less than.
 		}
 
@@ -739,7 +738,7 @@ protected void UpdateCleanupDelay()
 		//				}
 
 		//#if DEBUG
-		//				if (target.Where(t => t is DisposableBase).Cast<DisposableBase>().Any(t => t.IsDisposed))
+		//				if (target.Where(t => t is DisposableBase).Cast<DisposableBase>().Any(t => t.WasDisposed))
 		//					Debug.Fail("Disposed object retained in bag.");	
 		//#endif
 
@@ -758,7 +757,7 @@ protected override void OnCleanup()
 		{
 
 			// Prevents new locks from being acquired while a cleanup is active.
-			var lockHeld = CleanupManager.WriteConditional(write => !IsDisposed, () =>
+			var lockHeld = CleanupManager.WriteConditional(write => !WasDisposed, () =>
 			{
 				UpdateCleanupDelay();
 
@@ -770,15 +769,15 @@ protected override void OnCleanup()
 				//ContextPool.TrimTo(maxCount * 2);
 				LockPool.TrimTo(maxCount);
 
-				//if (Debugger.IsAttached && LockPool.Any(l => l.IsDisposed))
+				//if (Debugger.IsAttached && LockPool.Any(l => l.WasDisposed))
 				//	Debug.Fail("LockPool is retaining a disposed tracker.");
 
 				if (count == 0)
 					ClearCleanup();
 
 			}, 10000); // Use a timeout to ensure a busy collection isn't over locked.
 
-			if (IsDisposed) return;
+			if (WasDisposed) return;
 			if (lockHeld) return;
 			// Just to be sure...
 			Debug.WriteLine("ReadWriteHelper cleanup deferred.");