Merge pull request #111 from CommunityToolkit/dev/async-command-concurrency-notify

Fix AsyncRelayCommand with allowConcurrentExecutions == false not raising CanExecuteChanged

Author: Sergio0694

CommunityToolkit.Mvvm/Input/AsyncRelayCommand.cs

@@ -265,21 +265,33 @@ public Task ExecuteAsync(object? parameter)
     {
         if (CanExecute(parameter))
         {
-            // Non cancelable command delegate
+            Task executionTask;
+
             if (this.execute is not null)
             {
-                return ExecutionTask = this.execute();
+                // Non cancelable command delegate
+                executionTask = ExecutionTask = this.execute();
             }
+            else
+            {
+                // Cancel the previous operation, if one is pending
+                this.cancellationTokenSource?.Cancel();
+
+                CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource = new();
 
-            // Cancel the previous operation, if one is pending
-            this.cancellationTokenSource?.Cancel();
+                PropertyChanged?.Invoke(this, IsCancellationRequestedChangedEventArgs);
 
-            CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource = new();
+                // Invoke the cancelable command delegate with a new linked token
+                executionTask = ExecutionTask = this.cancelableExecute!(cancellationTokenSource.Token);
+            }
 
-            PropertyChanged?.Invoke(this, IsCancellationRequestedChangedEventArgs);
+            // If concurrent executions are disabled, notify the can execute change as well
+            if (!this.allowConcurrentExecutions)
+            {
+                CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+            }
 
-            // Invoke the cancelable command delegate with a new linked token
-            return ExecutionTask = this.cancelableExecute!(cancellationTokenSource.Token);
+            return executionTask;
         }
 
         return Task.CompletedTask;

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

@@ -269,21 +269,34 @@ public Task ExecuteAsync(T? parameter)
     {
         if (CanExecute(parameter))
         {
-            // Non cancelable command delegate
+            Task executionTask;
+
+            
             if (this.execute is not null)
             {
-                return ExecutionTask = this.execute(parameter);
+                // Non cancelable command delegate
+                executionTask = ExecutionTask = this.execute(parameter);
             }
+            else
+            {
+                // Cancel the previous operation, if one is pending
+                this.cancellationTokenSource?.Cancel();
+
+                CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource = new();
 
-            // Cancel the previous operation, if one is pending
-            this.cancellationTokenSource?.Cancel();
+                PropertyChanged?.Invoke(this, AsyncRelayCommand.IsCancellationRequestedChangedEventArgs);
 
-            CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource = new();
+                // Invoke the cancelable command delegate with a new linked token
+                executionTask = ExecutionTask = this.cancelableExecute!(parameter, cancellationTokenSource.Token);
+            }
 
-            PropertyChanged?.Invoke(this, AsyncRelayCommand.IsCancellationRequestedChangedEventArgs);
+            // If concurrent executions are disabled, notify the can execute change as well
+            if (!this.allowConcurrentExecutions)
+            {
+                CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+            }
 
-            // Invoke the cancelable command delegate with a new linked token
-            return ExecutionTask = this.cancelableExecute!(parameter, cancellationTokenSource.Token);
+            return executionTask;
         }
 
         return Task.CompletedTask;

tests/CommunityToolkit.Mvvm.UnitTests/Test_AsyncRelayCommand.cs

@@ -325,4 +325,97 @@ async void TestCallback(Action throwAction, Action completeAction)
 
         Assert.IsTrue(success);
     }
+
+    // See https://github.com/CommunityToolkit/dotnet/issues/108
+    [TestMethod]
+    public void Test_AsyncRelayCommand_ExecuteDoesNotRaiseCanExecuteChanged()
+    {
+        TaskCompletionSource<object?> tcs = new();
+
+        AsyncRelayCommand command = new(() => tcs.Task, allowConcurrentExecutions: true);
+
+        (object? Sender, EventArgs? Args) args = default;
+
+        command.CanExecuteChanged += (s, e) => args = (s, e);
+
+        Assert.IsTrue(command.CanExecute(null));
+
+        command.Execute(null);
+
+        Assert.IsNull(args.Sender);
+        Assert.IsNull(args.Args);
+
+        Assert.IsTrue(command.CanExecute(null));
+
+        tcs.SetResult(null);
+    }
+
+    [TestMethod]
+    public void Test_AsyncRelayCommand_ExecuteWithoutConcurrencyRaisesCanExecuteChanged()
+    {
+        TaskCompletionSource<object?> tcs = new();
+
+        AsyncRelayCommand command = new(() => tcs.Task, allowConcurrentExecutions: false);
+
+        (object? Sender, EventArgs? Args) args = default;
+
+        command.CanExecuteChanged += (s, e) => args = (s, e);
+
+        Assert.IsTrue(command.CanExecute(null));
+
+        command.Execute(null);
+
+        Assert.AreSame(command, args.Sender);
+        Assert.AreSame(EventArgs.Empty, args.Args);
+
+        Assert.IsFalse(command.CanExecute(null));
+
+        tcs.SetResult(null);
+    }
+
+    [TestMethod]
+    public void Test_AsyncRelayCommand_ExecuteDoesNotRaiseCanExecuteChanged_WithCancellation()
+    {
+        TaskCompletionSource<object?> tcs = new();
+
+        AsyncRelayCommand command = new(token => tcs.Task, allowConcurrentExecutions: true);
+
+        (object? Sender, EventArgs? Args) args = default;
+
+        command.CanExecuteChanged += (s, e) => args = (s, e);
+
+        Assert.IsTrue(command.CanExecute(null));
+
+        command.Execute(null);
+
+        Assert.IsNull(args.Sender);
+        Assert.IsNull(args.Args);
+
+        Assert.IsTrue(command.CanExecute(null));
+
+        tcs.SetResult(null);
+    }
+
+    [TestMethod]
+    public void Test_AsyncRelayCommand_ExecuteWithoutConcurrencyRaisesCanExecuteChanged_WithToken()
+    {
+        TaskCompletionSource<object?> tcs = new();
+
+        AsyncRelayCommand command = new(token => tcs.Task, allowConcurrentExecutions: false);
+
+        (object? Sender, EventArgs? Args) args = default;
+
+        command.CanExecuteChanged += (s, e) => args = (s, e);
+
+        Assert.IsTrue(command.CanExecute(null));
+
+        command.Execute(null);
+
+        Assert.AreSame(command, args.Sender);
+        Assert.AreSame(EventArgs.Empty, args.Args);
+
+        Assert.IsFalse(command.CanExecute(null));
+
+        tcs.SetResult(null);
+    }
 }

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

@@ -223,4 +223,95 @@ async void TestCallback(Action throwAction, Action completeAction)
 
         Assert.IsTrue(success);
     }
+
+    public void Test_AsyncRelayCommand_ExecuteDoesNotRaiseCanExecuteChanged()
+    {
+        TaskCompletionSource<object?> tcs = new();
+
+        AsyncRelayCommand<string> command = new(s => tcs.Task, allowConcurrentExecutions: true);
+
+        (object? Sender, EventArgs? Args) args = default;
+
+        command.CanExecuteChanged += (s, e) => args = (s, e);
+
+        Assert.IsTrue(command.CanExecute(""));
+
+        command.Execute("");
+
+        Assert.IsNull(args.Sender);
+        Assert.IsNull(args.Args);
+
+        Assert.IsTrue(command.CanExecute(""));
+
+        tcs.SetResult(null);
+    }
+
+    [TestMethod]
+    public void Test_AsyncRelayCommand_ExecuteWithoutConcurrencyRaisesCanExecuteChanged()
+    {
+        TaskCompletionSource<object?> tcs = new();
+
+        AsyncRelayCommand<string> command = new(s => tcs.Task, allowConcurrentExecutions: false);
+
+        (object? Sender, EventArgs? Args) args = default;
+
+        command.CanExecuteChanged += (s, e) => args = (s, e);
+
+        Assert.IsTrue(command.CanExecute(""));
+
+        command.Execute("");
+
+        Assert.AreSame(command, args.Sender);
+        Assert.AreSame(EventArgs.Empty, args.Args);
+
+        Assert.IsFalse(command.CanExecute(""));
+
+        tcs.SetResult(null);
+    }
+
+    [TestMethod]
+    public void Test_AsyncRelayCommand_ExecuteDoesNotRaiseCanExecuteChanged_WithCancellation()
+    {
+        TaskCompletionSource<object?> tcs = new();
+
+        AsyncRelayCommand<string> command = new((s, token) => tcs.Task, allowConcurrentExecutions: true);
+
+        (object? Sender, EventArgs? Args) args = default;
+
+        command.CanExecuteChanged += (s, e) => args = (s, e);
+
+        Assert.IsTrue(command.CanExecute(""));
+
+        command.Execute("");
+
+        Assert.IsNull(args.Sender);
+        Assert.IsNull(args.Args);
+
+        Assert.IsTrue(command.CanExecute(""));
+
+        tcs.SetResult(null);
+    }
+
+    [TestMethod]
+    public void Test_AsyncRelayCommand_ExecuteWithoutConcurrencyRaisesCanExecuteChanged_WithToken()
+    {
+        TaskCompletionSource<object?> tcs = new();
+
+        AsyncRelayCommand<string> command = new((s, token) => tcs.Task, allowConcurrentExecutions: false);
+
+        (object? Sender, EventArgs? Args) args = default;
+
+        command.CanExecuteChanged += (s, e) => args = (s, e);
+
+        Assert.IsTrue(command.CanExecute(""));
+
+        command.Execute("");
+
+        Assert.AreSame(command, args.Sender);
+        Assert.AreSame(EventArgs.Empty, args.Args);
+
+        Assert.IsFalse(command.CanExecute(""));
+
+        tcs.SetResult(null);
+    }
 }