Checkpoint.

Author: Oren (electricessence)

DisposableBase.cs

@@ -34,7 +34,8 @@ private void Dispose(bool calledExplicitly)
             if (!StartDispose())
                 return;
 
-			GC.SuppressFinalize(this);
+            if(calledExplicitly)
+			    GC.SuppressFinalize(this);
 
             try
             {

DisposableStateBase.cs

@@ -2,7 +2,7 @@
  * @author electricessence / https://github.com/electricessence/
  * Licensing: MIThttps://github.com/electricessence/Open.Disposable/blob/master/LISCENSE.md
  */
- 
+
 using System;
 using System.Threading;
 
@@ -16,11 +16,48 @@ public abstract class DisposableStateBase : IDisposalState
         protected const int DISPOSED = 2;
 
         // Since all write operations are done through Interlocked, no need for volatile.
-        private int _disposeState;
+        private int _disposeCalled = ALIVE;
+        private int _disposeState = ALIVE;
         public DisposeState DisposeState => (DisposeState)_disposeState;
+
+        /* This is important because some classes might react to disposal
+         * and still need access to the live class before it's disposed. */
+        #region Before Disposal
+		protected virtual void OnBeforeDispose() { }
+
+		/// <summary>
+		/// This event is triggered by the DisposeHelper immediately before 
+		/// </summary>
+		public event EventHandler BeforeDispose;
+		internal void FireBeforeDispose()
+		{
+			// Events should only fire if there are listeners...
+			if (BeforeDispose != null)
+			{
+				BeforeDispose(this, EventArgs.Empty);
+				BeforeDispose = null;
+			}
+		}
+        #endregion
+
+
         protected bool StartDispose()
-            => _disposeState == ALIVE
-            && Interlocked.CompareExchange(ref _disposeState, DISPOSING, ALIVE) == ALIVE;
+        {
+            if(_disposeCalled == ALIVE
+            && Interlocked.CompareExchange(ref _disposeCalled, DISPOSING, ALIVE) == ALIVE)
+            {
+                try {
+
+                }
+                finally {
+                    if(_disposeState == ALIVE)
+                        Interlocked.CompareExchange(ref _disposeState, DISPOSING, ALIVE);
+                }
+                return true;
+            }
+
+            return false;
+        }
 
         protected void Disposed()
             => Interlocked.Exchange(ref _disposeState, DISPOSED); // State.Disposed

README.md

@@ -17,3 +17,7 @@ It can be all too easy to allocate more memory by constructing more classes or s
 #### Plan for the worst, but code for the best
 
 Thread safety is important and in many cases should be assured.  But when the 99% case is the local use of a class, over-engineering can simply create unnecessary overhead and contention.
+
+#### Let the GC do its job
+
+Aggressively attempting to help out the garbage collector can be serious anti-pattern as you are simply slowing down your own application in order to avoid GC operations which might actually be helping your performance in total by deferring cleanup.