Merge branch 'Release-v4.0.0' of https://github.com/brminnick/AsyncAwaitBestPractices into Release-v4.0.0

Author: TheCodeTraveler

README.md

@@ -317,28 +317,24 @@ void OnActionEvent(string message) => _weakActionEventManager.HandleEvent(messag
 
 ### `AsyncCommand`
 
-Allows for `Task` and `ValueTask` to safely be used asynchronously with `ICommand`:
+Allows for `Task` to safely be used asynchronously with `ICommand`:
 
 - `AsyncCommand<T> : IAsyncCommand<T>`
 - `IAsyncCommand<T> : ICommand`
 - `AsyncCommand : IAsyncCommand`
 - `IAsyncCommand : ICommand`
-- `AsyncValueCommand<T> : IAsyncValueCommand<T>`
-- `IAsyncValueCommand<T> : ICommand`
-- `AsyncValueCommand : IAsyncValueCommand`
-- `IAsyncValueCommand : ICommand`
 
 ```csharp
 public AsyncCommand(Func<T, Task> execute,
-                     Func<object, bool> canExecute = null,
-                     Action<Exception> onException = null,
+                     Func<object, bool>? canExecute = null,
+                     Action<Exception>? onException = null,
                      bool continueOnCapturedContext = false)
 ```
 
 ```csharp
 public AsyncCommand(Func<Task> execute,
-                     Func<object, bool> canExecute = null,
-                     Action<Exception> onException = null,
+                     Func<object, bool>? canExecute = null,
+                     Action<Exception>? onException = null,
                      bool continueOnCapturedContext = false)
 ```
 
@@ -413,6 +409,110 @@ public class ExampleClass
 }
 ```
 
+### `AsyncValueCommand`
+
+Allows for `ValueTask` to safely be used asynchronously with `ICommand`.
+
+New to `ValueTask`? Check out this great write-up, [Understanding the Whys, Whats, and Whens of ValueTask
+](https://blogs.msdn.microsoft.com/dotnet/2018/11/07/understanding-the-whys-whats-and-whens-of-valuetask?WT.mc_id=asyncawaitbestpractices-github-bramin).
+
+- `AsyncValueCommand<T> : IAsyncValueCommand<T>`
+- `IAsyncValueCommand<T> : ICommand`
+- `AsyncValueCommand : IAsyncValueCommand`
+- `IAsyncValueCommand : ICommand`
+
+```csharp
+public AsyncValueCommand(Func<T, ValueTask> execute,
+                            Func<object, bool>? canExecute = null,
+                            Action<Exception>? onException = null,
+                            bool continueOnCapturedContext = false)
+```
+
+```csharp
+public AsyncValueCommand(Func<ValueTask> execute,
+                            Func<object, bool>? canExecute = null,
+                            Action<Exception>? onException = null,
+                            bool continueOnCapturedContext = false)
+```
+
+```csharp
+public class ExampleClass
+{
+    bool _isBusy;
+
+    public ExampleClass()
+    {
+        ExampleValueTaskCommand = new AsyncValueCommand(ExampleValueTaskMethod);
+        ExampleValueTaskIntCommand = new AsyncValueCommand<int>(ExampleValueTaskMethodWithIntParameter);
+        ExampleValueTaskExceptionCommand = new AsyncValueCommand(ExampleValueTaskMethodWithException, onException: ex => Debug.WriteLine(ex.ToString()));
+        ExampleValueTaskCommandWithCanExecuteChanged = new AsyncValueCommand(ExampleValueTaskMethod, _ => !IsBusy);
+        ExampleValueTaskCommandReturningToTheCallingThread = new AsyncValueCommand(ExampleValueTaskMethod, continueOnCapturedContext: true);
+    }
+
+    public IAsyncValueCommand ExampleValueTaskCommand { get; }
+    public IAsyncValueCommand<int> ExampleValueTaskIntCommand { get; }
+    public IAsyncValueCommand ExampleValueTaskExceptionCommand { get; }
+    public IAsyncValueCommand ExampleValueTaskCommandWithCanExecuteChanged { get; }
+    public IAsyncValueCommand ExampleValueTaskCommandReturningToTheCallingThread { get; }
+
+    public bool IsBusy
+    {
+        get => _isBusy;
+        set
+        {
+            if (_isBusy != value)
+            {
+                _isBusy = value;
+                ExampleValueTaskCommandWithCanExecuteChanged.RaiseCanExecuteChanged();
+            }
+        }
+    }
+
+    async ValueTask ExampleValueTaskMethod()
+    {
+        var random = new Random();
+        if (random.Next(10) > 9)
+            await Task.Delay(1000);
+    }
+
+    async ValueTask ExampleValueTaskMethodWithIntParameter(int parameter)
+    {
+        var random = new Random();
+        if (random.Next(10) > 9)
+            await Task.Delay(parameter);
+    }
+
+    async ValueTask ExampleValueTaskMethodWithException()
+    {
+        var random = new Random();
+        if (random.Next(10) > 9)
+            await Task.Delay(1000);
+
+        throw new Exception();
+    }
+
+    void ExecuteCommands()
+    {
+        _isBusy = true;
+
+        try
+        {
+            ExampleValueTaskCommand.Execute(null);
+            ExampleValueTaskIntCommand.Execute(1000);
+            ExampleValueTaskExceptionCommand.Execute(null);
+            ExampleValueTaskCommandReturningToTheCallingThread.Execute(null);
+
+            if (ExampleValueTaskCommandWithCanExecuteChanged.CanExecute(null))
+                ExampleValueTaskCommandWithCanExecuteChanged.Execute(null);
+        }
+        finally
+        {
+            _isBusy = false;
+        }
+    }
+}
+```
+
 ## Learn More
 - [Removing Async Void](https://johnthiriet.com/removing-async-void/)
 - [MVVM Going Async with Async Command](https://johnthiriet.com/mvvm-going-async-with-async-command/)