Improvements in disposed object exceptions.

Author: electricessence

benchmarking/Program.cs

@@ -20,7 +20,7 @@ static void Main()
         //TestEntry.Test1();
         //TestEntry.Test2();
         //QueueTests();
-		ListTests();
+		//ListTests();
         DictionaryTests();
 
         Console.Beep();
@@ -173,6 +173,7 @@ static void HashSetTests()
 
         report.AddBenchmark("LockSynchronizedHashSet",
             _ => () => new LockSynchronizedHashSet<object>());
+
         report.AddBenchmark("ReadWriteSynchronizedHashSet",
             _ => () => new ReadWriteSynchronizedHashSet<object>());
 
@@ -194,13 +195,12 @@ static void DictionaryTests()
 
         report.AddBenchmark("LockSynchronized Dictionary",
             _ => () => new LockSynchronizedDictionary<int, object>());
-        //report.AddBenchmark("ReadWriteSynchronized Dictionary",
-        //    _ => () => new ReadWriteSynchronizedDictionaryWrapper<int, object>());
 
         report.AddBenchmark("LockSynchronized OrderedDictionary",
             _ => () => new LockSynchronizedOrderedDictionary<int, object>());
-        //report.AddBenchmark("ReadWriteSynchronized OrderedDictionary",
-        //    _ => () => new ReadWriteSynchronizedDictionaryWrapper<int, object>(new OrderedDictionary<int, object>()));
+
+        report.AddBenchmark("LockSynchronized IndexedDictionary",
+            _ => () => new LockSynchronizedIndexedDictionary<int, object>());
 
         report.Pretest(200, 200); // Run once through first to scramble/warm-up initial conditions.
 

source/CollectionWrapper.cs

@@ -25,12 +25,16 @@ public CollectionWrapper(TCollection source, bool owner = false)
     #region Implementation of ICollection<T>
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    protected virtual void AddInternal(T item)
+    protected virtual void AddInternal(in T item)
         => InternalSource.Add(item);
 
     /// <inheritdoc />
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public virtual void Add(T item) => AddInternal(item);
+    public virtual void Add(T item)
+    {
+        AssertIsAlive();
+        AddInternal(in item);
+    }
 
     /// <inheritdoc cref="IAddMultiple{T}.AddThese(T, T, T[])"/>
     public virtual void AddThese(T item1, T item2, params T[] items)

source/DictionaryToHashSetWrapper.cs

@@ -68,7 +68,8 @@ public virtual bool Add(T item)
 
     /// <inheritdoc />
     [ExcludeFromCodeCoverage]
-    public IEnumerator<T> GetEnumerator() => InternalSource.Keys.GetEnumerator();
+    public IEnumerator<T> GetEnumerator()
+        => InternalSource.Keys.GetEnumerator();
 
     /// <inheritdoc />
     public void ExceptWith(IEnumerable<T> other)

source/DictionaryWrapper.cs

@@ -7,51 +7,60 @@ namespace Open.Collections;
 /// <inheritdoc />
 [ExcludeFromCodeCoverage]
 public class DictionaryWrapper<TKey, TValue>
-    : CollectionWrapper<KeyValuePair<TKey, TValue>, IDictionary<TKey, TValue>>, IDictionary<TKey, TValue>
+    : DictionaryWrapperBase<TKey, TValue, IDictionary<TKey, TValue>>
 {
     /// <inheritdoc />
-    public DictionaryWrapper(int capacity = 0)
-        : base(new Dictionary<TKey, TValue>(capacity), true)
-    {
-    }
+    public DictionaryWrapper()
+        : base(new Dictionary<TKey, TValue>(), true) { }
 
+    /// <inheritdoc />
+    public DictionaryWrapper(int capacity)
+        : base(new Dictionary<TKey, TValue>(capacity), true) { }
+
+    /// <inheritdoc />
     public DictionaryWrapper(IDictionary<TKey, TValue> source, bool owned = false)
         : base(source, owned)
     {
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     /// <inheritdoc />
-    public virtual TValue this[TKey key]
-    {
-        get => InternalSource[key];
-        set => InternalSource[key] = value;
-    }
+    protected override TValue GetValueInternal(TKey key)
+        => InternalSource[key];
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     /// <inheritdoc />
-    public virtual ICollection<TKey> Keys
-        => InternalSource.Keys;
+    protected override void SetValueInternal(TKey key, TValue value)
+        => InternalSource[key] = value;
 
-    /// <inheritdoc />
-    public virtual ICollection<TValue> Values
-        => InternalSource.Values;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override ICollection<TKey> GetKeys()
+        => new ReadOnlyCollectionAdapter<TKey>(
+            ThrowIfDisposed(InternalSource.Keys),
+            () => InternalSource.Count);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    /// <inheritdoc />
-    public virtual void Add(TKey key, TValue value)
-        => InternalSource.Add(key, value);
+    protected override ICollection<TValue> GetValues()
+        => new ReadOnlyCollectionAdapter<TValue>(
+            ThrowIfDisposed(InternalSource.Values),
+            () => InternalSource.Count);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected override void AddInternal(TKey key, TValue value)
+        => InternalSource.Add(key, value);
+
     /// <inheritdoc />
-    public virtual bool ContainsKey(TKey key)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override bool ContainsKey(TKey key)
         => InternalSource.ContainsKey(key);
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     /// <inheritdoc />
-    public virtual bool Remove(TKey key)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override bool Remove(TKey key)
         => InternalSource.Remove(key);
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     /// <inheritdoc />
-    public bool TryGetValue(TKey key, out TValue value)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override bool TryGetValue(TKey key, out TValue value)
         => InternalSource.TryGetValue(key, out value);
 }

source/DictionaryWrapperBase.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace Open.Collections;
+
+[ExcludeFromCodeCoverage]
+public abstract class DictionaryWrapperBase<TKey, TValue, TCollection>
+    : CollectionWrapper<KeyValuePair<TKey, TValue>, TCollection>, IDictionary<TKey, TValue>
+    where TCollection : class, ICollection<KeyValuePair<TKey, TValue>>
+{
+    protected DictionaryWrapperBase(TCollection source, bool owner = false)
+        : base(source, owner)
+    {
+    }
+
+    /// <inheritdoc />
+    public TValue this[TKey key]
+    {
+        get => GetValueInternal(key);
+        set => SetValueInternal(key, value);
+    }
+
+    protected abstract TValue GetValueInternal(TKey key);
+
+    protected abstract void SetValueInternal(TKey key, TValue value);
+
+    ICollection<TKey>? _keys;
+    /// <inheritdoc />
+    public ICollection<TKey> Keys => _keys ??= GetKeys();
+    protected abstract ICollection<TKey> GetKeys();
+
+    ICollection<TValue>? _values;
+
+    /// <inheritdoc />
+    public ICollection<TValue> Values => _values ??= GetValues();
+
+    protected abstract ICollection<TValue> GetValues();
+
+    protected abstract void AddInternal(TKey key, TValue value);
+
+    /// <inheritdoc />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(TKey key, TValue value)
+        => AddInternal(key, value);
+
+    /// <inheritdoc />
+    public abstract bool ContainsKey(TKey key);
+
+    /// <inheritdoc />
+    public abstract bool Remove(TKey key);
+
+    /// <inheritdoc />
+    public abstract bool TryGetValue(TKey key, out TValue value);
+}

source/Extensions.cs

@@ -980,4 +980,53 @@ public static ReadOnlyCollection<T> ToReadOnlyCollection<T>(this ReadOnlyMemory<
     /// <inheritdoc cref="ToImmutableArray{T}(ReadOnlyMemory{T})"/>
     public static ReadOnlyCollection<T> ToReadOnlyCollection<T>(this Memory<T> memory)
         => memory.Span.ToReadOnlyCollection();
+
+    /// <summary>
+    /// Executes an action before the enumerable is consumed.
+    /// </summary>
+    public static IEnumerable<T> Preflight<T>(
+        this IEnumerable<T> source,
+        Action before)
+    {
+        before();
+        foreach (var item in source)
+            yield return item;
+    }
+
+    /// <summary>
+    /// Executes an action before the enumerable is consumed.
+    /// </summary>
+    public static IEnumerator<T> Preflight<T>(
+        this IEnumerator<T> source,
+        Action before)
+    {
+        before();
+        while (source.MoveNext())
+            yield return source.Current;
+    }
+
+    public static IEnumerable<T> BeforeGetEnumerator<T>(
+        this IEnumerable<T> source,
+        Action before)
+        => new PreflightEnumerable<T>(source, before);
+
+    private class PreflightEnumerable<T> : IEnumerable<T>
+    {
+        private readonly IEnumerable<T> _source;
+        private readonly Action _before;
+
+        public PreflightEnumerable(IEnumerable<T> source, Action before)
+        {
+            _source = source ?? throw new ArgumentNullException(nameof(source));
+            _before = before ?? throw new ArgumentNullException(nameof(before));
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            _before();
+            return _source.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
 }

source/IOrderedDictionary.cs renamed to source/IIndexedDictionary.cs

@@ -8,28 +8,28 @@ namespace Open.Collections;
 /// Represents a generic items of key/value pairs that are ordered independently of the key and value.
 /// </summary>
 /// <inheritdoc />
-public interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+public interface IIndexedDictionary<TKey, TValue> : IDictionary<TKey, TValue>
 {
     /// <summary>
-    /// Adds an entry with the specified key and value into the <see cref="IOrderedDictionary{TKey,TValue}"/>.
+    /// Adds an entry with the specified key and value into the <see cref="IIndexedDictionary{TKey,TValue}"/>.
     /// </summary>
     /// <returns>The index of the newly added entry</returns>
     /// <inheritdoc cref="Insert(int, TKey, TValue)"/>
     new int Add(TKey key, TValue value);
 
     /// <summary>
-    /// Inserts a new entry into the <see cref="IOrderedDictionary{TKey,TValue}"/> items with the specified key and value at the specified index.
+    /// Inserts a new entry into the <see cref="IIndexedDictionary{TKey,TValue}"/> items with the specified key and value at the specified index.
     /// </summary>
     /// <param name="index">The zero-based index at which the element should be inserted.</param>
     /// <param name="key">The key of the entry to add.</param>
     /// <param name="value">The value of the entry to add. The value can be <see langword="null"/> if the type of the values in the dictionary is a reference type.</param>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is less than 0.<br/>
     /// -or-<br/>
     /// <paramref name="index"/> is greater than <see cref="System.Collections.ICollection.Count"/>.</exception>
-    /// <exception cref="ArgumentException">An element with the same key already exists in the <see cref="IOrderedDictionary{TKey,TValue}"/>.</exception>
-    /// <exception cref="NotSupportedException">The <see cref="IOrderedDictionary{TKey,TValue}"/> is read-only.<br/>
+    /// <exception cref="ArgumentException">An element with the same key already exists in the <see cref="IIndexedDictionary{TKey,TValue}"/>.</exception>
+    /// <exception cref="NotSupportedException">The <see cref="IIndexedDictionary{TKey,TValue}"/> is read-only.<br/>
     /// -or-<br/>
-    /// The <see cref="IOrderedDictionary{TKey,TValue}"/> has a fized size.</exception>
+    /// The <see cref="IIndexedDictionary{TKey,TValue}"/> has a fized size.</exception>
     void Insert(int index, TKey key, TValue value);
 
     /// <summary>
@@ -64,7 +64,7 @@ public interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>
     bool SetValueAt(int index, TValue value, out TKey key);
 
     /// <summary>
-    /// Removes the entry at the specified index from the <see cref="IOrderedDictionary{TKey,TValue}"/> items.
+    /// Removes the entry at the specified index from the <see cref="IIndexedDictionary{TKey,TValue}"/> items.
     /// </summary>
     /// <param name="index">The zero-based index of the entry to remove.</param>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is less than 0.<br/>