Checkpoint.

Author: electricessence

.editorconfig

@@ -219,3 +219,6 @@ dotnet_naming_style.begins_with_i.required_prefix = I
 dotnet_naming_style.begins_with_i.required_suffix = 
 dotnet_naming_style.begins_with_i.word_separator = 
 dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+# IDE0057: Use range operator
+dotnet_diagnostic.IDE0057.severity = silent

source/CollectionWrapper.cs

@@ -3,13 +3,22 @@
 
 namespace Open.Collections;
 
-public abstract class CollectionWrapper<T, TCollection> : ReadOnlyCollectionWrapper<T, TCollection>, ICollection<T>
+public class CollectionWrapper<T, TCollection> : ReadOnlyCollectionWrapper<T, TCollection>, ICollection<T>
 	where TCollection : class, ICollection<T>
 {
-	protected CollectionWrapper(TCollection source) : base(source)
+	public CollectionWrapper(TCollection source, bool owner = false)
+        : base(source, owner)
 	{
 	}
 
+    protected readonly object Sync = new(); // Could possibly override..
+
+    /// <summary>
+    /// The underlying object used for synchronization.
+    /// This is exposed to allow for more complex synchronization operations.
+    /// </summary>
+    public object SyncRoot => Sync;
+
     #region Implementation of ICollection<T>
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

source/DictionaryToHashSetWrapper.cs

@@ -9,7 +9,8 @@ public class DictionaryToHashSetWrapper<T> : ISet<T>
 	protected readonly IDictionary<T, bool> InternalSource;
 
 	// ReSharper disable once MemberCanBeProtected.Global
-	public DictionaryToHashSetWrapper(IDictionary<T, bool> source) => InternalSource = source;
+	public DictionaryToHashSetWrapper(IDictionary<T, bool> source)
+        => InternalSource = source;
 
 	/// <inheritdoc />
 	public int Count

source/DictionaryWrapper.cs

@@ -9,7 +9,12 @@ public class DictionaryWrapper<TKey, TValue>
 {
     /// <inheritdoc />
     public DictionaryWrapper(int capacity = 0)
-        : base(new Dictionary<TKey, TValue>(capacity))
+        : base(new Dictionary<TKey, TValue>(capacity), true)
+    {
+    }
+
+    public DictionaryWrapper(IDictionary<TKey, TValue> source, bool owned = false)
+        : base(source, owned)
     {
     }
 

source/GlobalSuppressions.cs

@@ -2,9 +2,15 @@
 using System.Runtime.CompilerServices;
 
 namespace Open.Collections;
-public abstract class ListWrapper<T> : CollectionWrapper<T, IList<T>>, IList<T>
+public class ListWrapper<T> : CollectionWrapper<T, IList<T>>, IList<T>
 {
-    protected ListWrapper(IList<T> source) : base(source)
+    public ListWrapper(int capacity = 0)
+        : base(new List<T>(capacity), true)
+    {
+    }
+
+    public ListWrapper(IList<T> source, bool owner = false)
+        : base(source, owner)
     {
     }
 

source/ListWrapper.cs

@@ -10,9 +10,22 @@ public class ReadOnlyCollectionWrapper<T, TCollection> : DisposableBase, IReadOn
 		where TCollection : class, ICollection<T>
 {
 	protected TCollection InternalSource;
+    protected readonly bool SourceOwned;
 
-	protected ReadOnlyCollectionWrapper(TCollection source)
-        => InternalSource = source ?? throw new ArgumentNullException(nameof(source));
+    /// <summary>
+    /// Constructs a wrapper for read-only access to a collection.
+    /// </summary>
+    /// <param name="source">The source collection.</param>
+    /// <param name="owner">
+    /// If <see langword="true"/>, will call <paramref name="source"/>.Dispose() if the source is <see cref="IDisposable"/> when this is disposed.<br/>
+    /// And will throw <see cref="NotSupportedException"/> to prevent direct access to the source when .ExtractAndDispose() is called.
+    /// </param>
+    /// <exception cref="ArgumentNullException">If the <paramref name="source"/> is <see langword="null"/>.</exception>
+	public ReadOnlyCollectionWrapper(TCollection source, bool owner = false)
+    {
+        InternalSource = source ?? throw new ArgumentNullException(nameof(source));
+        SourceOwned = owner;
+    }
 
     #region Implementation of IReadOnlyCollection<T>
     /// <inheritdoc cref="ICollection&lt;T&gt;.Contains(T)" />
@@ -52,15 +65,21 @@ public virtual Span<T> CopyTo(Span<T> span)
     public virtual void Export(ICollection<T> to)
         => to.Add(InternalSource);
 
-	#region Dispose
-	protected override void OnDispose() => Nullify(ref InternalSource);
+    #region Dispose
+    protected override void OnDispose()
+    {
+        var source = Nullify(ref InternalSource);
+        if (SourceOwned && source is IDisposable d) d.Dispose();
+    }
 
-	/// <summary>
-	/// Extracts the underlying collection and returns it before disposing of this synchronized wrapper.
-	/// </summary>
-	/// <returns>The extracted underlying collection.</returns>
-	public TCollection ExtractAndDispose()
+    /// <summary>
+    /// Extracts the underlying collection and returns it before disposing of this synchronized wrapper.
+    /// </summary>
+    /// <returns>The extracted underlying collection.</returns>
+    /// <exception cref="NotSupportedException">If the underlying collection is owned by this wrapper.</exception>
+    public TCollection ExtractAndDispose()
 	{
+        if (SourceOwned) throw new NotSupportedException("The underlying collection is owned by this wrapper.");
 		using (this)
 		{
 			return Nullify(ref InternalSource);

source/ReadOnlyCollectionWrapper.cs

@@ -13,8 +13,6 @@ public class SimpleOrderedDictionary<TKey, TValue>
     private readonly List<TKey> _keys;
     private readonly List<TValue> _values;
 
-    public object SyncRoot { get; } = new object();
-
     public SimpleOrderedDictionary(int capacity = 0)
         : base(capacity)
     {

source/SimpleOrderedDictionary.cs

@@ -19,26 +19,26 @@ public class ConcurrentList<T> : ListWrapper<T>, ISynchronizedCollection<T>
     public override int Count => _count;
     private readonly ConcurrentQueue<T> _buffer = new();
     private readonly ReaderWriterLockSlim _sync = new();
-    private ReaderWriterLockSlim Sync
+    private ReaderWriterLockSlim RWLock
         => AssertIsAlive() ? _sync : null!;
 
     protected override void OnDispose()
     {
         Clear();
-        Sync.Dispose();
+        RWLock.Dispose();
         base.OnDispose();
     }
 
     private void DumpBuffer()
     {
         if (_buffer.IsEmpty) return;
-        using var write = Sync.WriteLock();
+        using var write = RWLock.WriteLock();
         DumpBufferUnlocked();
     }
 
     private void DumpBufferUnlocked()
     {
-        Debug.Assert(Sync.IsWriteLockHeld);
+        Debug.Assert(RWLock.IsWriteLockHeld);
         while (_buffer.TryDequeue(out var item))
             InternalSource.Add(item);
     }
@@ -77,18 +77,18 @@ protected override void AddInternal(T item)
     /// <inheritdoc />
     public override int IndexOf(T item)
     {
-        int i = Sync.Read(() => base.IndexOf(item));
+        int i = RWLock.Read(() => base.IndexOf(item));
         if (i != -1 || _buffer.IsEmpty) return i;
         DumpBuffer(); // one dump then accept results.
-        return Sync.Read(() => base.IndexOf(item));
+        return RWLock.Read(() => base.IndexOf(item));
     }
 
     /// <inheritdoc />
     public override void Insert(int index, T item)
     {
         AssertValidIndex(index);
         DumpBuffer();
-        using var write = Sync.WriteLock();
+        using var write = RWLock.WriteLock();
         base.Insert(index, item);
         Interlocked.Increment(ref _count);
     }
@@ -103,15 +103,15 @@ public override void RemoveAt(int index)
 
     private void RemoveAtCore(int index)
     {
-        using var write = Sync.WriteLock();
+        using var write = RWLock.WriteLock();
         base.RemoveAt(index);
         Interlocked.Decrement(ref _count);
     }
 
     /// <inheritdoc />
     public override bool Remove(T item)
         // Assume the majority case is that the item exists.
-        => Sync.ReadUpgradeable(() =>
+        => RWLock.ReadUpgradeable(() =>
         {
             DumpBuffer();
             int i = base.IndexOf(item);
@@ -122,7 +122,7 @@ public override bool Remove(T item)
 
     /// <inheritdoc />
     public override void Clear()
-        => Sync.Write(() =>
+        => RWLock.Write(() =>
         {
             DumpBufferUnlocked();
             int i = InternalSource.Count;
@@ -138,7 +138,7 @@ public override bool Contains(T item)
     public override void CopyTo(T[] array, int arrayIndex)
     {
         DumpBuffer();
-        Sync.Read(() => base.CopyTo(array, arrayIndex));
+        RWLock.Read(() => base.CopyTo(array, arrayIndex));
     }
 
     /// <inheritdoc />
@@ -152,6 +152,6 @@ public override IEnumerator<T> GetEnumerator()
     public T[] Snapshot()
     {
         DumpBuffer();
-        return Sync.Read(()=>InternalSource.ToArray());
+        return RWLock.Read(()=>InternalSource.ToArray());
     }
 }

source/Synchronized/ConcurrentList.cs

@@ -8,14 +8,8 @@ namespace Open.Collections.Synchronized;
 public class LockSynchronizedCollectionWrapper<T, TCollection> : CollectionWrapper<T, TCollection>, ISynchronizedCollectionWrapper<T, TCollection>
 		where TCollection : class, ICollection<T>
 {
-	protected LockSynchronizedCollectionWrapper(TCollection source) : base(source) => Sync = source;
-
-	protected readonly object Sync; // Could possibly override..
-
-	/// <summary>
-	/// The underlying object used for synchronization.  This is exposed to allow for more complex synchronization operations.
-	/// </summary>
-	public object SyncRoot => Sync;
+    protected LockSynchronizedCollectionWrapper(TCollection source)
+        : base(source) { }
 
 	#region Implementation of ICollection<T>
 
@@ -156,9 +150,9 @@ public virtual bool IfContains(T item, Action<TCollection> action)
 	{
 		lock (Sync)
 		{
-            bool contains = InternalSource.Contains(item);
-			if (contains) action(InternalSource);
-			return contains;
+            if (!InternalSource.Contains(item)) return false;
+            action(InternalSource);
+            return true;
 		}
 	}
 
@@ -167,9 +161,9 @@ public virtual bool IfNotContains(T item, Action<TCollection> action)
 	{
 		lock (Sync)
 		{
-            bool notContains = !InternalSource.Contains(item);
-			if (notContains) action(InternalSource);
-			return notContains;
-		}
-	}
+            if (InternalSource.Contains(item)) return false;
+            action(InternalSource);
+            return true;
+        }
+    }
 }