Updated for release with both .NET Standard 2.0 and 2.1

Author: Oren (electricessence)

AsyncDisposableBase.cs

@@ -1,31 +1,69 @@
 /*!
  * @author electricessence / https://github.com/electricessence/
- * Licensing: MIThttps://github.com/electricessence/Open.Disposable/blob/master/LISCENSE.md
+ * Licensing: MIT https://github.com/electricessence/Open.Disposable/blob/master/LISCENSE.md
  */
 
 using System.Threading.Tasks;
 
 namespace Open.Disposable
 {
-    public abstract class AsyncDisposableBase
-        : DisposableStateBase, Open.Disposable.Async.IAsyncDisposable
-    {
-        protected abstract ValueTask OnDisposeAsync();
+	/// <summary>
+	/// A base class for properly implementing IAsyncDisposable but also allowing for synchronous use of IDispose.
+	/// Only implementing OnDisposeAsync is enough to properly handle disposal.
+	/// </summary>
+    public abstract class AsyncDisposableBase : DisposableBase
+#if NETSTANDARD2_1
+			,System.IAsyncDisposable
+#endif
+	{
+		/// <summary>
+		/// Without overriding OnDispose, OnDisposeAsync will be called no matter what depending on how the object is disposed.
+		/// </summary>
+		/// <param name="mode">The method by which disposal was triggered.</param>
+		protected abstract ValueTask OnDisposeAsync(AsyncDisposeMode mode);
 
-        /// <inheritdoc />
-        public ValueTask DisposeAsync()
+		/// <inheritdoc />
+		/// <summary>
+		/// If overridden, expect OnDisposeAsync to be called only when DisposeAsync is called, unless base.OnDispose(calledExplicitly) is implemented.
+		/// </summary>
+		protected override void OnDispose(bool calledExplicitly)
+		{
+			var dispose = OnDisposeAsync(calledExplicitly ? AsyncDisposeMode.Dispose : AsyncDisposeMode.Finalized);
+			// Was it purely synchronous?
+			if(!dispose.IsCompletedSuccessfully)
+			{
+				/*
+				 * If the OnDisposeAsync method doesn't complete immediately
+				 * (it could internally defer an action with a task)
+				 * then it's a signal that we must wait.
+				 */
+
+				dispose.AsTask().Wait();
+
+				/* This is obviously not ideal, but is a good fallback for this case. */
+			}
+		}
+
+		/// <inheritdoc />
+		public ValueTask DisposeAsync()
         {
-            if (!StartDispose())
+            /*
+             * Note about the BeforeDispose event:
+             * Although this is asynchronous, it's not this class' responsibility to decide how subscribers will behave.
+             * A subscriber should smartly defer responses when possible, or only respond in a properly synchronous non-blockin way.
+             */
+
+            if (!StartDispose(true))
                 return new ValueTask();
 
             var dispose = true;
             try
             {
-                var d = OnDisposeAsync();
+                var d = OnDisposeAsync(AsyncDisposeMode.DisposeAsync);
                 if (!d.IsCompletedSuccessfully)
                 {
                     dispose = false;
-                    return OnDisposeAsyncInternal();
+                    return OnDisposeAsyncInternal(d);
                 }
             }
             finally
@@ -36,11 +74,11 @@ public ValueTask DisposeAsync()
             return new ValueTask();
         }
 
-        private async ValueTask OnDisposeAsyncInternal()
+        private async ValueTask OnDisposeAsyncInternal(ValueTask onDispose)
         {
             try
             {
-                await OnDisposeAsync();
+                await onDispose;
             }
             finally
             {

AsyncDisposeHandler.cs

@@ -18,7 +18,7 @@ public AsyncDisposeHandler(Func<ValueTask> action)
 
 		Func<ValueTask> _action;
 
-		protected override ValueTask OnDisposeAsync()
+		protected override ValueTask OnDisposeAsync(AsyncDisposeMode mode)
 			=> Interlocked.Exchange(ref _action, null).Invoke();
 	}
 }

AsyncDisposeMode.cs

@@ -0,0 +1,14 @@
+/*!
+ * @author electricessence / https://github.com/electricessence/
+ * Licensing: MIT https://github.com/electricessence/Open.Disposable/blob/master/LISCENSE.md
+ */
+
+namespace Open.Disposable
+{
+	public enum AsyncDisposeMode
+	{
+		Dispose,
+		DisposeAsync,
+		Finalized
+	}
+}

DeferredCleanupBase.cs

@@ -3,12 +3,11 @@
  * Licensing: MIThttps://github.com/electricessence/Open.Disposable/blob/master/LISCENSE.md
  */
 
-using Open.Diagnostics;
 using System;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 
-
 namespace Open.Disposable
 {
 	public abstract class DeferredCleanupBase : DisposableBase
@@ -66,7 +65,7 @@ protected void ResetTimer()
 
 		public void SetCleanup(CleanupMode mode = CleanupMode.Deferred)
 		{
-			if (IsDisposed)
+			if (WasDisposed)
 				return;
 
 			switch (mode)
@@ -96,7 +95,7 @@ public void SetCleanup(CleanupMode mode = CleanupMode.Deferred)
 				case CleanupMode.ImmediateDeferred:
 					lock (_timerSync)
 					{
-						if (!IsDisposed && LastCleanup != DateTime.MaxValue)
+						if (!WasDisposed && LastCleanup != DateTime.MaxValue)
 						{
 							// No past due action in order to prevent another thread from firing...
 							LastCleanup = DateTime.MaxValue;
@@ -114,10 +113,10 @@ public void SetCleanup(CleanupMode mode = CleanupMode.Deferred)
 
 		public void DeferCleanup()
 		{
-			if (IsDisposed) return;
+			if (WasDisposed) return;
 			lock (_timerSync)
 			{
-				if (IsDisposed) return;
+				if (WasDisposed) return;
 				IsRunning = true;
 
 				if (_cleanupTimer == null)
@@ -141,7 +140,7 @@ public void ClearCleanup()
 
 		private void Cleanup(object state = null)
 		{
-			if (IsDisposed)
+			if (WasDisposed)
 				return; // If another thread enters here after disposal don't allow.
 
 			try
@@ -150,10 +149,9 @@ private void Cleanup(object state = null)
 			}
 			catch (Exception ex)
 			{
-				ex.WriteToDebug();
+				Debug.WriteLine(ex.ToString());
 			}
 
-
 			lock (_timerSync)
 			{
 				LastCleanup = DateTime.Now;

DisposableBase.cs

@@ -4,15 +4,14 @@
  */
 
 using System;
+using System.Diagnostics;
 
 namespace Open.Disposable
 {
-
-    /// <summary>
-    /// A base class for implementing other disposables.  Properly implements the (thread-safe) dispose pattern using DisposeHelper.
-    /// 
-    /// Provides useful properties and methods to allow for checking if this instance has already been disposed and provides a "BeforeDispose" event for other classes to react to.
-    /// </summary>
+	/// <summary>
+	/// A base class for properly implementing the synchronous dispose pattern.
+	/// Implement OnDispose to handle disposal.
+	/// </summary>
     public abstract class DisposableBase : DisposableStateBase, IDisposable
 	{
         /// <inheritdoc />
@@ -27,20 +26,51 @@ public void Dispose()
 			Dispose(false);
 		}
 
+		/// <summary>
+		/// When implemented will be called (only once) when being disposed.
+		/// </summary>
+		/// <param name="calledExplicitly">True if called through code in the runtime, or false if finalized by the garbage collector.</param>
 		protected abstract void OnDispose(bool calledExplicitly);
 
-        private void Dispose(bool calledExplicitly)
+		protected bool StartDispose(bool calledExplicitly)
+		{
+			try
+			{
+				if (StartDispose())
+					return true;
+
+				// Already called?  No need to GC suppress.
+				calledExplicitly = false;
+				return false;
+			}
+			catch (Exception eventBeforeDisposeException) when (!calledExplicitly)
+			{
+				if (Debugger.IsAttached)
+					Debug.Fail(eventBeforeDisposeException.ToString());
+
+				return true; // If we even got this far with !calledExplicitly then it must be the first time and we should proceed.
+			}
+			finally
+			{
+				if (calledExplicitly)
+					GC.SuppressFinalize(this);
+			}
+		}
+
+		private void Dispose(bool calledExplicitly)
         {
-            if (!StartDispose())
-                return;
+			if (!StartDispose(calledExplicitly))
+				return;
 
-            if(calledExplicitly)
-			    GC.SuppressFinalize(this);
-
             try
             {
 				OnDispose(calledExplicitly);
             }
+            catch (Exception onDisposeException) when (!calledExplicitly)
+            {
+                if (Debugger.IsAttached)
+                    Debug.Fail(onDisposeException.ToString());
+            }             
             finally
             {
                 Disposed();