Added improved handlers.

Author: Oren (electricessence)

AsyncDisposeHandler.cs

@@ -19,6 +19,22 @@ public AsyncDisposeHandler(Func<ValueTask> action)
 		Func<ValueTask> _action;
 
 		protected override ValueTask OnDisposeAsync(AsyncDisposeMode mode)
-			=> Interlocked.Exchange(ref _action, null).Invoke();
+			=> Nullify(ref _action).Invoke();
+	}
+
+	public class AsyncDisposeHandler<T> : AsyncDisposeHandler
+	{
+		public AsyncDisposeHandler(T value, Func<ValueTask> action) : base(action)
+		{
+			Value = value;
+		}
+
+		public T Value { get; private set; }
+
+		protected override ValueTask OnDisposeAsync(AsyncDisposeMode mode)
+		{
+			Value = default;
+			return base.OnDisposeAsync(mode);
+		}
 	}
 }

DisposableBase.cs

@@ -32,7 +32,7 @@ public void Dispose()
 		/// <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);
 
-		protected bool StartDispose(bool calledExplicitly)
+		internal protected bool StartDispose(bool calledExplicitly)
 		{
 			try
 			{

DisposeHandler.cs

@@ -21,4 +21,20 @@ protected override void OnDispose(bool calledExplicitly)
 			=> Interlocked.Exchange(ref _action, null).Invoke();
 
 	}
+
+	public class DisposeHandler<T> : DisposeHandler
+	{
+		public DisposeHandler(T value, Action action) :base(action)
+		{
+			Value = value;
+		}
+
+		public T Value { get; private set; }
+
+		protected override void OnDispose(bool calledExplicitly)
+		{
+			Value = default;
+			base.OnDispose(calledExplicitly);
+		}
+	}
 }

Extensions.cs

@@ -4,6 +4,7 @@
  */
 
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics.Contracts;
 using System.Linq;
@@ -52,5 +53,28 @@ public static void Dispose<T>(this ICollection<T> target, bool disposeContents =
 			target.Clear();
 			if (target is IDisposable t) t.Dispose();
 		}
+
+		const int MaxPoolArraySize = 1024 * 1024;
+		static void Dummy() { }
+
+		/// <summary>
+		/// Rents a buffer from the ArrayPool but returns a DisposeHandler with the buffer as it's value.
+		/// Facilitiates containing the temporary use of a buffer within a using block.
+		/// If the mimimumLength exceeds 1024*1024, an array will be created at that length for use.
+		/// </summary>
+		/// <typeparam name="T">The type of the array.</typeparam>
+		/// <param name="pool">The pool to get the array from.</param>
+		/// <param name="minimumLength">The minimum length of the array.</param>
+		/// <param name="clearArrayOnReturn">If true, will clear the array when it is returned to the pool.</param>
+		/// <returns>A DisposeHandler containing an array of type T[] that is at least minimumLength in length.</returns>
+		public static DisposeHandler<T[]> RentDisposable<T>(this ArrayPool<T> pool, int minimumLength, bool clearArrayOnReturn = false)
+		{
+			// If the size is too large, facilitate getting an array but don't manage the pool.
+			if (minimumLength > MaxPoolArraySize)
+				return new DisposeHandler<T[]>(new T[minimumLength], Dummy);
+
+			var a = pool.Rent(minimumLength);
+			return new DisposeHandler<T[]>(a, () => pool.Return(a, clearArrayOnReturn));
+		}
 	}
 }

Open.Disposable.csproj

@@ -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.0-preview3</Version>
+    <Version>2.0.1</Version>
     <PackageReleaseNotes></PackageReleaseNotes>
-    <AssemblyVersion>2.0.0.3</AssemblyVersion>
-    <FileVersion>2.0.0.3</FileVersion>
+    <AssemblyVersion>2.0.1.0</AssemblyVersion>
+    <FileVersion>2.0.1.0</FileVersion>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>
 
@@ -41,6 +41,7 @@
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.2" />
+    <PackageReference Include="System.Memory" Version="4.5.3" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' ">

README.md

@@ -24,16 +24,24 @@ Aggressively attempting to help out the garbage collector can be serious anti-pa
 
 ## Classes
 
-### DisposableBase
+### `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.
 
-### AsyncDisposableBase
+> 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.
+
+### `DisposeHandler` & `AsyncDisposeHandler`
+
+A simple set of classes for triggering an action (once) when disposed.  Can also contain a value (T) which is cleared on dispose.