support ValueTask<T> (#203)

* support ValueTask<T>

* fix tests

* add test

---------

Co-authored-by: Edward Miller <[email protected]>

Author: symbiogenesis

src/AsyncAwaitBestPractices.UnitTests/BaseTest.cs

@@ -42,6 +42,31 @@ protected static async Task IntParameterDelayedNullReferenceExceptionTask(int de
 		throw new NullReferenceException();
 	}
 
+	protected static async ValueTask NoParameterValueTask() => await Task.Delay(Delay);
+	protected static async ValueTask IntParameterValueTask(int delay) => await Task.Delay(delay);
+	protected static async ValueTask NullableIntParameterValueTask(int? delay) => await Task.Delay(delay ?? Delay);
+	protected static async ValueTask StringParameterValueTask(string? text) => await Task.Delay(Delay);
+	protected static ValueTask NoParameterImmediateNullReferenceExceptionValueTask() => throw new NullReferenceException();
+	protected static ValueTask ParameterImmediateNullReferenceExceptionValueTask(int delay) => throw new NullReferenceException();
+
+	protected static async ValueTask NoParameterDelayedNullReferenceExceptionValueTask()
+	{
+		await Task.Delay(Delay);
+		throw new NullReferenceException();
+	}
+
+	protected static async ValueTask<bool> NoParameterDelayedNullReferenceExceptionValueTaskWithReturn()
+	{
+		await Task.Delay(Delay);
+		throw new NullReferenceException();
+	}
+
+	protected static async ValueTask IntParameterDelayedNullReferenceExceptionValueTask(int delay)
+	{
+		await Task.Delay(delay);
+		throw new NullReferenceException();
+	}
+
 	protected static bool CanExecuteTrue(bool parameter) => true;
 	protected static bool CanExecuteTrue(int parameter) => true;
 	protected static bool CanExecuteTrue(string? parameter) => true;

src/AsyncAwaitBestPractices.UnitTests/SafeFireAndForgetTests/Tests_ValueTask_SafeFIreAndForgetT.cs

@@ -27,7 +27,7 @@ public async Task SafeFireAndForget_HandledException()
 		NullReferenceException? exception = null;
 
 		//Act
-		NoParameterDelayedNullReferenceExceptionTask().SafeFireAndForget<NullReferenceException>(ex => exception = ex);
+		NoParameterDelayedNullReferenceExceptionValueTask().SafeFireAndForget<NullReferenceException>(ex => exception = ex);
 		await BaseTest.NoParameterTask();
 		await BaseTest.NoParameterTask();
 
@@ -43,14 +43,35 @@ public async Task SafeFireAndForgetT_SetDefaultExceptionHandling_NoParams()
 		SafeFireAndForgetExtensions.SetDefaultExceptionHandling(ex => exception = ex);
 
 		//Act
-		NoParameterDelayedNullReferenceExceptionTask().SafeFireAndForget();
+		NoParameterDelayedNullReferenceExceptionValueTask().SafeFireAndForget();
 		await BaseTest.NoParameterTask();
 		await BaseTest.NoParameterTask();
 
 		//Assert
 		Assert.That(exception, Is.Not.Null);
 	}
 
+	[Test]
+	public async Task SafeFireAndForgetT_SetDefaultExceptionHandling_WithParam()
+	{
+		//Arrange
+		Exception? exception1 = null;
+		NullReferenceException? exception2 = null;
+		SafeFireAndForgetExtensions.SetDefaultExceptionHandling(ex => exception1 = ex);
+
+		//Act
+		NoParameterDelayedNullReferenceExceptionValueTask().SafeFireAndForget<NullReferenceException>(ex => exception2 = ex);
+		await BaseTest.NoParameterTask();
+		await BaseTest.NoParameterTask();
+
+		Assert.Multiple(() =>
+		{
+			//Assert
+			Assert.That(exception1, Is.Not.Null);
+			Assert.That(exception2, Is.Not.Null);
+		});
+	}
+
 	[Test]
 	public async Task SafeFireAndForgetT_SetDefaultExceptionHandling_WithParams()
 	{
@@ -60,7 +81,7 @@ public async Task SafeFireAndForgetT_SetDefaultExceptionHandling_WithParams()
 		SafeFireAndForgetExtensions.SetDefaultExceptionHandling(ex => exception1 = ex);
 
 		//Act
-		NoParameterDelayedNullReferenceExceptionTask().SafeFireAndForget<NullReferenceException>(ex => exception2 = ex);
+		NoParameterDelayedNullReferenceExceptionValueTaskWithReturn().SafeFireAndForget<bool, NullReferenceException>(ex => exception2 = ex);
 		await BaseTest.NoParameterTask();
 		await BaseTest.NoParameterTask();
 

src/AsyncAwaitBestPractices.UnitTests/SafeFireAndForgetTests/Tests_ValueTask_SafeFireAndForget.cs

@@ -27,7 +27,7 @@ public async Task SafeFireAndForget_HandledException()
 		Exception? exception = null;
 
 		//Act
-		NoParameterDelayedNullReferenceExceptionTask().SafeFireAndForget(ex => exception = ex);
+		NoParameterDelayedNullReferenceExceptionValueTask().SafeFireAndForget(ex => exception = ex);
 		await BaseTest.NoParameterTask();
 		await BaseTest.NoParameterTask();
 
@@ -43,7 +43,7 @@ public async Task SafeFireAndForget_SetDefaultExceptionHandling_NoParams()
 		SafeFireAndForgetExtensions.SetDefaultExceptionHandling(ex => exception = ex);
 
 		//Act
-		NoParameterDelayedNullReferenceExceptionTask().SafeFireAndForget();
+		NoParameterDelayedNullReferenceExceptionValueTask().SafeFireAndForget();
 		await BaseTest.NoParameterTask();
 		await BaseTest.NoParameterTask();
 
@@ -60,7 +60,7 @@ public async Task SafeFireAndForget_SetDefaultExceptionHandling_WithParams()
 		SafeFireAndForgetExtensions.SetDefaultExceptionHandling(ex => exception1 = ex);
 
 		//Act
-		NoParameterDelayedNullReferenceExceptionTask().SafeFireAndForget(ex => exception2 = ex);
+		NoParameterDelayedNullReferenceExceptionValueTask().SafeFireAndForget(ex => exception2 = ex);
 		await BaseTest.NoParameterTask();
 		await BaseTest.NoParameterTask();
 

src/AsyncAwaitBestPractices/SafeFireAndForgetExtensions.extensions.shared.cs

@@ -16,6 +16,14 @@ public static partial class SafeFireAndForgetExtensions
 	/// <param name="continueOnCapturedContext">If set to <c>true</c>, continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c>, continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
 	public static void SafeFireAndForget(this ValueTask task, Action<Exception>? onException, bool continueOnCapturedContext = false) => task.SafeFireAndForget(in onException, in continueOnCapturedContext);
 
+	/// <summary>
+	/// Safely execute the ValueTask without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.
+	/// </summary>
+	/// <param name="task">ValueTask.</param>
+	/// <param name="onException">If an exception is thrown in the ValueTask, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+	/// <param name="continueOnCapturedContext">If set to <c>true</c>, continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c>, continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+	/// <typeparam name="T">The return value of the ValueTask.</typeparam>
+	public static void SafeFireAndForget<T>(this ValueTask<T> task, Action<Exception>? onException, bool continueOnCapturedContext = false) => task.SafeFireAndForget(in onException, in continueOnCapturedContext);
 
 	/// <summary>
 	/// Safely execute the ValueTask without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.
@@ -26,6 +34,15 @@ public static partial class SafeFireAndForgetExtensions
 	/// <typeparam name="TException">Exception type. If an exception is thrown of a different type, it will not be handled</typeparam>
 	public static void SafeFireAndForget<TException>(this ValueTask task, Action<TException>? onException, bool continueOnCapturedContext = false) where TException : Exception => task.SafeFireAndForget(in onException, in continueOnCapturedContext);
 
+	/// <summary>
+	/// Safely execute the ValueTask without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.
+	/// </summary>
+	/// <param name="task">ValueTask.</param>
+	/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+	/// <param name="continueOnCapturedContext">If set to <c>true</c>, continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c>, continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+	/// <typeparam name="T">The return value of the ValueTask.</typeparam>
+	/// <typeparam name="TException">Exception type. If an exception is thrown of a different type, it will not be handled</typeparam>
+	public static void SafeFireAndForget<T, TException>(this ValueTask<T> task, Action<TException>? onException, bool continueOnCapturedContext = false) where TException : Exception => task.SafeFireAndForget(in onException, in continueOnCapturedContext);
 
 	/// <summary>
 	/// Safely execute the Task without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.

src/AsyncAwaitBestPractices/SafeFireAndForgetExtensions.shared.cs

@@ -19,6 +19,14 @@ public static partial class SafeFireAndForgetExtensions
 	/// <param name="continueOnCapturedContext">If set to <c>true</c>, continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c>, continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
 	public static void SafeFireAndForget(this ValueTask task, in Action<Exception>? onException = null, in bool continueOnCapturedContext = false) => HandleSafeFireAndForget(task, continueOnCapturedContext, onException);
 
+	/// <summary>
+	/// Safely execute the ValueTask without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.
+	/// </summary>
+	/// <param name="task">ValueTask.</param>
+	/// <param name="onException">If an exception is thrown in the ValueTask, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+	/// <param name="continueOnCapturedContext">If set to <c>true</c>, continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c>, continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+	/// <typeparam name="T">The return value of the ValueTask.</typeparam>
+	public static void SafeFireAndForget<T>(this ValueTask<T> task, in Action<Exception>? onException = null, in bool continueOnCapturedContext = false) => HandleSafeFireAndForget(task, continueOnCapturedContext, onException);
 
 	/// <summary>
 	/// Safely execute the ValueTask without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.
@@ -29,6 +37,16 @@ public static partial class SafeFireAndForgetExtensions
 	/// <typeparam name="TException">Exception type. If an exception is thrown of a different type, it will not be handled</typeparam>
 	public static void SafeFireAndForget<TException>(this ValueTask task, in Action<TException>? onException = null, in bool continueOnCapturedContext = false) where TException : Exception => HandleSafeFireAndForget(task, continueOnCapturedContext, onException);
 
+	/// <summary>
+	/// Safely execute the ValueTask without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.
+	/// </summary>
+	/// <param name="task">ValueTask.</param>
+	/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+	/// <param name="continueOnCapturedContext">If set to <c>true</c>, continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c>, continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+	/// <typeparam name="T">The return value of the ValueTask.</typeparam>
+	/// <typeparam name="TException">Exception type. If an exception is thrown of a different type, it will not be handled</typeparam>
+	public static void SafeFireAndForget<T, TException>(this ValueTask<T> task, in Action<TException>? onException = null, in bool continueOnCapturedContext = false) where TException : Exception => HandleSafeFireAndForget(task, continueOnCapturedContext, onException);
+
 #if NET8_0_OR_GREATER
 	/// <summary>
 	/// Safely execute the Task without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.
@@ -105,6 +123,21 @@ static async void HandleSafeFireAndForget<TException>(ValueTask valueTask, bool
 		}
 	}
 
+	static async void HandleSafeFireAndForget<T, TException>(ValueTask<T> valueTask, bool continueOnCapturedContext, Action<TException>? onException) where TException : Exception
+	{
+		try
+		{
+			await valueTask.ConfigureAwait(continueOnCapturedContext);
+		}
+		catch (TException ex) when (_onException is not null || onException is not null)
+		{
+			HandleException(ex, onException);
+
+			if (_shouldAlwaysRethrowException)
+				throw;
+		}
+	}
+
 	static async void HandleSafeFireAndForget<TException>(Task task, bool continueOnCapturedContext, Action<TException>? onException) where TException : Exception
 	{
 		try