Merge pull request #139 from CommunityToolkit/dev/fix-command-no-concurrency-can-execute

Fix async relay command CanExecute raised with no concurrency

Author: Sergio0694

CommunityToolkit.Mvvm/Input/AsyncRelayCommand.cs

@@ -237,6 +237,11 @@ static async void MonitorTask(AsyncRelayCommand @this, Task task)
                     {
                         @this.PropertyChanged?.Invoke(@this, CanBeCanceledChangedEventArgs);
                     }
+
+                    if (!@this.allowConcurrentExecutions)
+                    {
+                        @this.CanExecuteChanged?.Invoke(@this, EventArgs.Empty);
+                    }
                 }
             }
 

CommunityToolkit.Mvvm/Input/AsyncRelayCommand{T}.cs

@@ -219,6 +219,11 @@ static async void MonitorTask(AsyncRelayCommand<T> @this, Task task)
                     {
                         @this.PropertyChanged?.Invoke(@this, AsyncRelayCommand.CanBeCanceledChangedEventArgs);
                     }
+
+                    if (!@this.allowConcurrentExecutions)
+                    {
+                        @this.CanExecuteChanged?.Invoke(@this, EventArgs.Empty);
+                    }
                 }
             }
 

tests/CommunityToolkit.Mvvm.UnitTests/Test_AsyncRelayCommand.cs

@@ -207,6 +207,8 @@ public async Task Test_AsyncRelayCommand_AllowConcurrentExecutions_Enable()
         Assert.AreSame(args.Item1, command);
         Assert.AreSame(args.Item2, EventArgs.Empty);
 
+        args = default;
+
         Assert.IsNull(command.ExecutionTask);
         Assert.IsFalse(command.IsRunning);
 
@@ -236,6 +238,10 @@ public async Task Test_AsyncRelayCommand_AllowConcurrentExecutions_Enable()
         _ = await Task.WhenAll(cancellationTokenSources[0].Task, cancellationTokenSources[1].Task);
 
         Assert.IsFalse(command.IsRunning);
+
+        // CanExecute isn't raised again when the command completes, if concurrent executions are allowed
+        Assert.IsNull(args.Item1);
+        Assert.IsNull(args.Item2);
     }
 
     [TestMethod]
@@ -275,11 +281,19 @@ private static async Task Test_AsyncRelayCommand_AllowConcurrentExecutions_TestL
         Assert.AreSame(args.Item1, command);
         Assert.AreSame(args.Item2, EventArgs.Empty);
 
+        args = default;
+
         Assert.IsNull(command.ExecutionTask);
         Assert.IsFalse(command.IsRunning);
 
         Task task = command.ExecuteAsync(null);
 
+        // CanExecute is raised upon execution
+        Assert.AreSame(args.Item1, command);
+        Assert.AreSame(args.Item2, EventArgs.Empty);
+
+        args = default;
+
         Assert.IsNotNull(command.ExecutionTask);
         Assert.AreSame(command.ExecutionTask, task);
         Assert.IsTrue(command.IsRunning);
@@ -291,11 +305,19 @@ private static async Task Test_AsyncRelayCommand_AllowConcurrentExecutions_TestL
         Assert.IsFalse(command.CanBeCanceled);
         Assert.IsFalse(command.IsCancellationRequested);
 
+        // CanExecute hasn't been raised again
+        Assert.IsNull(args.Item1);
+        Assert.IsNull(args.Item2);
+
         tcs.SetResult(null);
 
         await task;
 
         Assert.IsFalse(command.IsRunning);
+
+        // CanExecute is raised automatically when command execution completes, if concurrent executions are disabled
+        Assert.AreSame(args.Item1, command);
+        Assert.AreSame(args.Item2, EventArgs.Empty);
     }
 
     [TestMethod]

tests/CommunityToolkit.Mvvm.UnitTests/Test_AsyncRelayCommand{T}.cs

@@ -267,7 +267,7 @@ async void TestCallback(Action throwAction, Action completeAction)
         Assert.IsTrue(success);
     }
 
-    public void Test_AsyncRelayCommand_ExecuteDoesNotRaiseCanExecuteChanged()
+    public async Task Test_AsyncRelayCommand_ExecuteDoesNotRaiseCanExecuteChanged()
     {
         TaskCompletionSource<object?> tcs = new();
 
@@ -284,13 +284,21 @@ public void Test_AsyncRelayCommand_ExecuteDoesNotRaiseCanExecuteChanged()
         Assert.IsNull(args.Sender);
         Assert.IsNull(args.Args);
 
+        args = default;
+
         Assert.IsTrue(command.CanExecute(""));
 
         tcs.SetResult(null);
+
+        _ = await tcs.Task;
+
+        // CanExecute isn't raised when the command completes
+        Assert.IsNull(args.Sender);
+        Assert.IsNull(args.Args);
     }
 
     [TestMethod]
-    public void Test_AsyncRelayCommand_ExecuteWithoutConcurrencyRaisesCanExecuteChanged()
+    public async Task Test_AsyncRelayCommand_ExecuteWithoutConcurrencyRaisesCanExecuteChanged()
     {
         TaskCompletionSource<object?> tcs = new();
 
@@ -309,7 +317,15 @@ public void Test_AsyncRelayCommand_ExecuteWithoutConcurrencyRaisesCanExecuteChan
 
         Assert.IsFalse(command.CanExecute(""));
 
+        args = default;
+
         tcs.SetResult(null);
+
+        _ = await tcs.Task;
+
+        // CanExecute is raised again when the command completes
+        Assert.AreSame(command, args.Sender);
+        Assert.AreSame(EventArgs.Empty, args.Args);
     }
 
     [TestMethod]