Udpated reference.

Author: electricessence

source/Extensions.Generic.Synchronized.cs

@@ -225,7 +225,7 @@ public static T GetOrAddSynchronized<TKey, T>(
 		Contract.EndContractBlock();
 
 		T result = default!;
-		bool condition(LockType _) => !target.TryGetValue(key, out result);
+		bool condition(bool _) => !target.TryGetValue(key, out result);
 
 		void render()
 		{
@@ -257,7 +257,7 @@ public static T GetOrAddSynchronized<TKey, T>(
 
 		T result = default!;
 		// Note, the following sync read is on the TARGET and not the key. See below.
-		bool condition(LockType _) => !ThreadSafety.SynchronizeRead(target, () => target.TryGetValue(key, out result));
+		bool condition(bool _) => !ThreadSafety.SynchronizeRead(target, () => target.TryGetValue(key, out result));
 
 		// Once a per value write lock is established, execute the scheduler, and syncronize adding...
 		void render() => target.GetOrAddSynchronized(key, result = valueFactory(key), millisecondsTimeout);

source/LazyList.cs

@@ -59,7 +59,7 @@ protected override bool EnsureIndex(int maxIndex)
         // This is where the fun begins...
         // Mutliple threads can be out of sync (probably through a memory barrier)
         // And a sync read operation must be done to ensure safety.
-        int count = Sync.ReadValue(() => _cached.Count);
+        int count = Sync.Read(() => _cached.Count);
 		if (maxIndex < count)
 		{
 			// We're still within the existing results, but safe count is not up to date.
@@ -73,38 +73,36 @@ protected override bool EnsureIndex(int maxIndex)
 		if (_enumerator is null)
 			return false;
 
-		// This very well could be a simple lock{} statement but the ReaderWriterLockSlim recursion protection is actually quite useful.
-		using (UpgradableReadLock? uLock = Sync.UpgradableReadLock())
-		{
+        // This very well could be a simple lock{} statement but the ReaderWriterLockSlim recursion protection is actually quite useful.
+        using var uLock = Sync.UpgradableReadLock();
             // Note: Within an upgradable read, other reads pile up.
 
-            int c = _cached.Count;
-			if (_safeCount != c) // Always do comparisons outside of interlocking first.
-				Interlocked.CompareExchange(ref _safeCount, c, _safeCount);
-
-			if (maxIndex < _safeCount)
-				return true;
+        int c = _cached.Count;
+		if (_safeCount != c) // Always do comparisons outside of interlocking first.
+			Interlocked.CompareExchange(ref _safeCount, c, _safeCount);
 
-			if (_enumerator is null)
-				return false;
+		if (maxIndex < _safeCount)
+			return true;
 
-			uLock.UpgradeToWriteLock();
+		if (_enumerator is null)
+			return false;
 
-			while (_enumerator.MoveNext())
-			{
-				if (_cached.Count == int.MaxValue)
-					throw new Exception("Reached maximium contents for a single list.  Cannot memoize further.");
+		using var wLock = Sync.WriteLock();
 
-				_cached.Add(_enumerator.Current);
+		while (_enumerator.MoveNext())
+		{
+			if (_cached.Count == int.MaxValue)
+				throw new Exception("Reached maximium contents for a single list.  Cannot memoize further.");
 
-				if (maxIndex < _cached.Count)
-					return true;
-			}
+			_cached.Add(_enumerator.Current);
 
-			IsEndless = false;
-			DisposeOf(ref _enumerator);
+			if (maxIndex < _cached.Count)
+				return true;
 		}
 
+		IsEndless = false;
+		DisposeOf(ref _enumerator);
+
 		return false;
 	}
 

source/NonGeneric/Extensions.Synchronized.cs

@@ -164,7 +164,7 @@ public static T GetOrAddSynchronized<T>(
 
 		T result = default!;
 		// Uses threadsafe means to acquire value.
-		bool condition(LockType _) => !target.TryGetValue(key, out result);
+		bool condition(bool _) => !target.TryGetValue(key, out result);
 
 		void render()
 		{
@@ -194,7 +194,7 @@ public static T GetOrAddSynchronized<T>(
 		ValidateMillisecondsTimeout(millisecondsTimeout);
 
 		T result = default!;
-		bool condition(LockType _) => !ThreadSafety.SynchronizeRead(target, () => target.TryGetValue(key, out result));
+		bool condition(bool _) => !ThreadSafety.SynchronizeRead(target, () => target.TryGetValue(key, out result));
 
 		// Once a per value write lock is established, execute the scheduler, and syncronize adding...
 		void render() => target.GetOrAddSynchronized(key, result = valueFactory(key), millisecondsTimeout);

source/Open.Collections.csproj

@@ -44,8 +44,8 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Open.Text" Version="6.0.2" />
-		<PackageReference Include="Open.Threading" Version="1.6.8" />
+		<PackageReference Include="Open.Text" Version="6.1.0" />
+		<PackageReference Include="Open.Threading" Version="2.0.0-preview1" />
 		<PackageReference Include="System.Collections.Immutable" Version="6.0.0" />
 	</ItemGroup>
 

source/Synchronized/ReadWriteSynchronizedCollectionWrapper.cs

@@ -45,19 +45,19 @@ public override void Clear()
 
 	/// <inheritdoc />
 	public override bool Contains(T item)
-        => Sync.ReadValue(() => InternalSource.Contains(item));
+        => Sync.Read(() => InternalSource.Contains(item));
 
     /// <inheritdoc />
     public override bool Remove(T item)
         => IfContains(item, c => c.Remove(item));
 
     /// <inheritdoc />
     public override int Count
-		=> Sync.ReadValue(() => InternalSource.Count);
+		=> Sync.Read(() => InternalSource.Count);
 
 	/// <inheritdoc />
 	public T[] Snapshot()
-        => Sync.ReadValue(() => InternalSource.ToArray());
+        => Sync.Read(() => InternalSource.ToArray());
 
 	/// <inheritdoc />
 	public override void Export(ICollection<T> to)
@@ -110,40 +110,40 @@ public void ForEach(Action<T> action, bool useSnapshot = true)
 
 	/// <inheritdoc />
 	public void Modify(Func<bool> condition, Action<TCollection> action)
-		=> Sync.ReadWriteConditionalOptimized(_ => condition(), () => action(InternalSource));
+		=> Sync.ReadWriteConditional(_ => condition(), () => action(InternalSource));
 
 	/// <summary>
 	/// Allows for multiple modifications at once.
 	/// </summary>
 	/// <param name="condition">Only executes the action if the condition is true.  The condition may be invoked more than once.</param>
 	/// <param name="action">The action to execute safely on the underlying collection safely.</param>
-	public void Modify(Func<LockType, bool> condition, Action<TCollection> action)
-		=> Sync.ReadWriteConditionalOptimized(condition, () => action(InternalSource));
+	public void Modify(Func<bool, bool> condition, Action<TCollection> action)
+		=> Sync.ReadWriteConditional(condition, () => action(InternalSource));
 
 	/// <inheritdoc />
 	public void Modify(Action<TCollection> action) => Sync.Write(()
 		=> action(InternalSource));
 
 	/// <inheritdoc />
 	public TResult Modify<TResult>(Func<TCollection, TResult> action)
-		=> Sync.WriteValue(() => action(InternalSource));
+		=> Sync.Write(() => action(InternalSource));
 
 	/// <inheritdoc />
 	public virtual bool IfContains(T item, Action<TCollection> action)
 	{
-        using var syncLock = Sync.UpgradableReadLock();
+        using var uLock = Sync.UpgradableReadLock();
         if (!InternalSource.Contains(item)) return false;
-        syncLock.UpgradeToWriteLock();
+        using var wLock = Sync.WriteLock();
         action(InternalSource);
         return true;
 	}
 
 	/// <inheritdoc />
 	public virtual bool IfNotContains(T item, Action<TCollection> action)
 	{
-        using var syncLock = Sync.UpgradableReadLock();
+        using var uLock = Sync.UpgradableReadLock();
         if (!InternalSource.Contains(item)) return false;
-        syncLock.UpgradeToWriteLock();
+        using var wLock = Sync.WriteLock();
         action(InternalSource);
         return true;
 	}

source/Synchronized/ReadWriteSynchronizedHashSet.cs

@@ -31,27 +31,27 @@ public void IntersectWith(IEnumerable<T> other)
 
 	/// <inheritdoc />
 	public bool IsProperSubsetOf(IEnumerable<T> other)
-		=> Sync.ReadValue(() => InternalSource.IsProperSubsetOf(other));
+		=> Sync.Read(() => InternalSource.IsProperSubsetOf(other));
 
 	/// <inheritdoc />
 	public bool IsProperSupersetOf(IEnumerable<T> other)
-		=> Sync.ReadValue(() => InternalSource.IsProperSupersetOf(other));
+		=> Sync.Read(() => InternalSource.IsProperSupersetOf(other));
 
 	/// <inheritdoc />
 	public bool IsSubsetOf(IEnumerable<T> other)
-		=> Sync.ReadValue(() => InternalSource.IsSubsetOf(other));
+		=> Sync.Read(() => InternalSource.IsSubsetOf(other));
 
 	/// <inheritdoc />
 	public bool IsSupersetOf(IEnumerable<T> other)
-		=> Sync.ReadValue(() => InternalSource.IsSupersetOf(other));
+		=> Sync.Read(() => InternalSource.IsSupersetOf(other));
 
 	/// <inheritdoc />
 	public bool Overlaps(IEnumerable<T> other)
-		=> Sync.ReadValue(() => InternalSource.Overlaps(other));
+		=> Sync.Read(() => InternalSource.Overlaps(other));
 
 	/// <inheritdoc />
 	public bool SetEquals(IEnumerable<T> other)
-		=> Sync.ReadValue(() => InternalSource.SetEquals(other));
+		=> Sync.Read(() => InternalSource.SetEquals(other));
 
 	/// <inheritdoc />
 	public void SymmetricExceptWith(IEnumerable<T> other)

source/Synchronized/ReadWriteSynchronizedLinkedList.cs

@@ -17,45 +17,56 @@ public LinkedListNode<T> Last
 		=> InternalSource.Last;
 
 	/// <inheritdoc />
-	public LinkedListNode<T> AddAfter(LinkedListNode<T> node, T item) => Sync.WriteValue(() => InternalSource.AddAfter(node, item));
+	public LinkedListNode<T> AddAfter(LinkedListNode<T> node, T item)
+        => Sync.Write(() => InternalSource.AddAfter(node, item));
 
 	/// <inheritdoc />
-	public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode) => Sync.Write(() => InternalSource.AddAfter(node, newNode));
+	public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode)
+        => Sync.Write(() => InternalSource.AddAfter(node, newNode));
 
 	/// <inheritdoc />
-	public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T item) => Sync.WriteValue(() => InternalSource.AddBefore(node, item));
+	public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T item)
+        => Sync.Write(() => InternalSource.AddBefore(node, item));
 
 	/// <inheritdoc />
-	public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode) => Sync.Write(() => InternalSource.AddBefore(node, newNode));
+	public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode)
+        => Sync.Write(() => InternalSource.AddBefore(node, newNode));
 
 	/// <inheritdoc />
-	public LinkedListNode<T> AddFirst(T item) => Sync.WriteValue(() => InternalSource.AddFirst(item));
+	public LinkedListNode<T> AddFirst(T item)
+        => Sync.Write(() => InternalSource.AddFirst(item));
 
 	/// <inheritdoc />
-	public void AddFirst(LinkedListNode<T> newNode) => Sync.Write(() => InternalSource.AddFirst(newNode));
+	public void AddFirst(LinkedListNode<T> newNode)
+        => Sync.Write(() => InternalSource.AddFirst(newNode));
 
 	/// <inheritdoc />
-	public LinkedListNode<T> AddLast(T item) => Sync.WriteValue(() => InternalSource.AddLast(item));
+	public LinkedListNode<T> AddLast(T item)
+        => Sync.Write(() => InternalSource.AddLast(item));
 
 	/// <inheritdoc />
-	public void AddLast(LinkedListNode<T> newNode) => Sync.Write(() => InternalSource.AddLast(newNode));
+	public void AddLast(LinkedListNode<T> newNode)
+        => Sync.Write(() => InternalSource.AddLast(newNode));
 
 	/// <inheritdoc />
-	public void Remove(LinkedListNode<T> node) => Sync.Write(() => InternalSource.Remove(node));
+	public void Remove(LinkedListNode<T> node)
+        => Sync.Write(() => InternalSource.Remove(node));
 
 	/// <inheritdoc />
-	public void RemoveFirst() => Sync.Write(() => InternalSource.RemoveFirst());
+	public void RemoveFirst() => Sync.Write(()
+        => InternalSource.RemoveFirst());
 
 	/// <inheritdoc />
-	public void RemoveLast() => Sync.Write(() => InternalSource.RemoveLast());
+	public void RemoveLast() => Sync.Write(()
+        => InternalSource.RemoveLast());
 
 	/// <inheritdoc />
 	public bool TryTakeFirst(out T item)
 	{
         bool success = false;
 		LinkedListNode<T>? node = null;
 		T result = default!;
-		Sync.ReadWriteConditionalOptimized(
+		Sync.ReadWriteConditional(
 			_ => (node = InternalSource.First) is not null,
 			() =>
 			{
@@ -73,7 +84,7 @@ public bool TryTakeLast(out T item)
         bool success = false;
 		LinkedListNode<T>? node = null;
 		T result = default!;
-		Sync.ReadWriteConditionalOptimized(
+		Sync.ReadWriteConditional(
 			_ => (node = InternalSource.Last) is not null,
 			() =>
 			{

source/Synchronized/ReadWriteSynchronizedListWrapper.cs

@@ -19,11 +19,14 @@ public T this[int index]
 	}
 
 	/// <inheritdoc />
-	public int IndexOf(T item) => Sync.ReadValue(() => InternalSource.IndexOf(item));
+	public int IndexOf(T item)
+        => Sync.Read(() => InternalSource.IndexOf(item));
 
 	/// <inheritdoc />
-	public void Insert(int index, T item) => Sync.Write(() => InternalSource.Insert(index, item));
+	public void Insert(int index, T item)
+        => Sync.Write(() => InternalSource.Insert(index, item));
 
 	/// <inheritdoc />
-	public void RemoveAt(int index) => Sync.Write(() => InternalSource.RemoveAt(index));
+	public void RemoveAt(int index)
+        => Sync.Write(() => InternalSource.RemoveAt(index));
 }