Updates to eliminate inherent finalization.

Author: Oren (electricessence)

AsyncDisposableBase.cs

@@ -11,38 +11,16 @@ namespace Open.Disposable
 	/// 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
+    public abstract class AsyncDisposableBase : DisposableStateBase
 #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 />
-		/// <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. */
-			}
-		}
+		/// <param name="asynchronous">If true, was called by .DisposeAsync(), otherwise.</param>
+		protected abstract ValueTask OnDisposeAsync();
 
 		/// <inheritdoc />
 		public ValueTask DisposeAsync()
@@ -53,13 +31,13 @@ public ValueTask DisposeAsync()
              * A subscriber should smartly defer responses when possible, or only respond in a properly synchronous non-blockin way.
              */
 
-            if (!StartDispose(true))
+            if (!StartDispose())
                 return new ValueTask();
 
             var dispose = true;
             try
             {
-                var d = OnDisposeAsync(AsyncDisposeMode.DisposeAsync);
+                var d = OnDisposeAsync();
                 if (!d.IsCompletedSuccessfully)
                 {
                     dispose = false;

AsyncDisposeHandler.cs

@@ -4,7 +4,6 @@
  */
 
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Open.Disposable
@@ -18,7 +17,7 @@ public AsyncDisposeHandler(Func<ValueTask> action)
 
 		Func<ValueTask> _action;
 
-		protected override ValueTask OnDisposeAsync(AsyncDisposeMode mode)
+		protected override ValueTask OnDisposeAsync()
 			=> Nullify(ref _action).Invoke();
 	}
 
@@ -31,10 +30,10 @@ public AsyncDisposeHandler(T value, Func<ValueTask> action) : base(action)
 
 		public T Value { get; private set; }
 
-		protected override ValueTask OnDisposeAsync(AsyncDisposeMode mode)
+		protected override ValueTask OnDisposeAsync()
 		{
 			Value = default;
-			return base.OnDisposeAsync(mode);
+			return base.OnDisposeAsync();
 		}
 	}
 }

AsyncDisposeMode.cs

@@ -161,7 +161,12 @@ private void Cleanup(object state = null)
 
 		protected abstract void OnCleanup();
 
-		protected override void OnDispose(bool calledExplicitly)
+		protected override void OnDispose()
+		{
+			ResetTimer();
+		}
+
+		~DeferredCleanupBase()
 		{
 			ResetTimer();
 		}

DeferredCleanupBase.cs

@@ -4,78 +4,35 @@
  */
 
 using System;
-using System.Diagnostics;
 
 namespace Open.Disposable
 {
 	/// <summary>
 	/// A base class for properly implementing the synchronous dispose pattern.
 	/// Implement OnDispose to handle disposal.
 	/// </summary>
-    public abstract class DisposableBase : DisposableStateBase, IDisposable
+	public abstract class DisposableBase : DisposableStateBase, IDisposable
 	{
-        /// <inheritdoc />
+		/// <inheritdoc />
 		public void Dispose()
 		{
-			Dispose(true);
-		}
-
-		// Being called by the GC...
-		~DisposableBase()
-		{
-			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);
+			if (!StartDispose())
+				return;
 
-		internal 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.
+				OnDispose();
 			}
 			finally
 			{
-				if (calledExplicitly)
-					GC.SuppressFinalize(this);
+				Disposed();
 			}
 		}
 
-		private void Dispose(bool calledExplicitly)
-        {
-			if (!StartDispose(calledExplicitly))
-				return;
-			
-            try
-            {
-				OnDispose(calledExplicitly);
-            }
-            catch (Exception onDisposeException) when (!calledExplicitly)
-            {
-                if (Debugger.IsAttached)
-                    Debug.Fail(onDisposeException.ToString());
-            }             
-            finally
-            {
-                Disposed();
-            }
-        }
+		/// <summary>
+		/// When implemented will be called (only once) when being disposed.
+		/// </summary>
+		protected abstract void OnDispose();
 	}
 
 }

DisposableBase.cs

@@ -4,7 +4,6 @@
  */
 
 using System;
-using System.Threading;
 
 namespace Open.Disposable
 {
@@ -17,8 +16,8 @@ public DisposeHandler(Action action)
 
 		Action _action;
 
-		protected override void OnDispose(bool calledExplicitly)
-			=> Interlocked.Exchange(ref _action, null).Invoke();
+		protected override void OnDispose()
+			=> Nullify(ref _action).Invoke();
 
 	}
 
@@ -31,10 +30,10 @@ public DisposeHandler(T value, Action action) :base(action)
 
 		public T Value { get; private set; }
 
-		protected override void OnDispose(bool calledExplicitly)
+		protected override void OnDispose()
 		{
 			Value = default;
-			base.OnDispose(calledExplicitly);
+			base.OnDispose();
 		}
 	}
 }

DisposeHandler.cs

@@ -17,10 +17,10 @@
     <PackageProjectUrl>https://github.com/electricessence/Open.Disposable/</PackageProjectUrl>
     <RepositoryUrl>https://github.com/electricessence/Open.Disposable/</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <Version>2.0.1</Version>
+    <Version>2.1.0</Version>
     <PackageReleaseNotes></PackageReleaseNotes>
-    <AssemblyVersion>2.0.1.0</AssemblyVersion>
-    <FileVersion>2.0.1.0</FileVersion>
+    <AssemblyVersion>2.1.0.0</AssemblyVersion>
+    <FileVersion>2.1.0.0</FileVersion>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>
 

Open.Disposable.csproj

@@ -5,7 +5,7 @@ Provides a set of useful classes when implementing a disposable.
 ## Core principles
 
 * For most use cases, disposal should only occur once and be final.
-* Implementing `IDisposable` in combination with `IAsyncDisposable` is not typical but can be facilitated.
+* Implementing `IDisposable` in combination with `IAsyncDisposable` is not typical and should be avoided.  The consumer should understand the difference.
 * `.Dispose()` and `.DisposeAsync()` should be thread-safe and calling either multiple times should not block or throw. (Typically done through an interlock method.)
 
 ### Avoid anti-patterns
@@ -26,21 +26,13 @@ Aggressively attempting to help out the garbage collector can be serious anti-pa
 
 ### `DisposableBase`
 
-Simply implement `void OnDispose(bool calledExplicitly)` in order to manage disposal.
-
-If `calledExplicitly` is `true`, then the `.Dispose()` method was called by the code.  If `false`, the class was finalized by the GC.
+Simply implement `void OnDispose()` in order to manage disposal.
 
 > Note: `DisposableBase` exposes a `BeforeDispose` event which will be triggered once just before disposing commences.  This allows for others to react to this disposal event.  The `DisposableBase` is still considered 'live' until after the `BeforeDispose` event cycle has completed.
 
 ### `AsyncDisposableBase`
 
-Inherits from `DisposableBase`.
-
-Simply implement `ValueTask OnDisposeAsync(AsyncDisposeMode mode)` in order to manage disposal.
-
-Dispose accordingly based upon the `AsyncDisposeMode`.
-
-It is also possible to override `void OnDispose(bool calledExplicitly)` to manage synchronous disposal separate from asynchronous disposal, but should it must be understood that overriding without calling `base.OnDispose(calledExplicitly)` will mean that `OnDisposeAsync(AsyncDisposeMode mode)` will not automatically be called.  Essentially meaning if you override, you should prepare for one or the other, but not both.
+Simply implement `ValueTask OnDisposeAsync()` in order to manage disposal.
 
 ### `DisposeHandler` & `AsyncDisposeHandler`