Fix #4

Author: ChebanovDD

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncCommand.T.cs

@@ -18,6 +18,11 @@ public AsyncCommand(Func<T, CancellationToken, UniTask> action, Func<bool> canEx
 
         public void Execute(T parameter)
         {
+            if (IsRunning && AllowConcurrency == false)
+            {
+                return;
+            }
+
             ExecuteAsync(parameter).Forget();
         }
 

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncCommand.cs

@@ -18,6 +18,11 @@ public AsyncCommand(Func<CancellationToken, UniTask> action, Func<bool> canExecu
 
         public void Execute()
         {
+            if (IsRunning && AllowConcurrency == false)
+            {
+                return;
+            }
+
             ExecuteAsync().Forget();
         }
 

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncLazyCommand.T.cs

@@ -5,6 +5,7 @@ namespace UnityMvvmToolkit.UniTask
     using Core;
     using System;
     using Interfaces;
+    using Extensions;
     using System.Runtime.CompilerServices;
 
     public abstract class BaseAsyncCommand : BaseCommand, IBaseAsyncCommand
@@ -25,6 +26,8 @@ protected set
             }
         }
 
+        public bool AllowConcurrency { get; set; }
+
         public virtual bool DisableOnExecution { get; set; }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -40,6 +43,8 @@ public override bool CanExecute()
 
         public virtual void Cancel()
         {
+            throw new InvalidOperationException(
+                $"To make the 'AsyncCommand' cancelable, use '{nameof(AsyncCommandExtensions.WithCancellation)}' extension.");
         }
     }
 }

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncLazyCommand.T.cs.meta

@@ -15,7 +15,9 @@ public static IAsyncCommand WithCancellation(this IAsyncCommand asyncCommand)
                 throw new NullReferenceException(nameof(asyncCommand));
             }
 
-            return new AsyncCommandWithCancellation(asyncCommand);
+            return asyncCommand.AllowConcurrency
+                ? new AsyncCommandWithCancellation(asyncCommand)
+                : new AsyncLazyCommandWithCancellation(asyncCommand);
         }
 
         public static IAsyncCommand<T> WithCancellation<T>(this IAsyncCommand<T> asyncCommand)
@@ -25,7 +27,9 @@ public static IAsyncCommand<T> WithCancellation<T>(this IAsyncCommand<T> asyncCo
                 throw new NullReferenceException(nameof(asyncCommand));
             }
 
-            return new AsyncCommandWithCancellation<T>(asyncCommand);
+            return asyncCommand.AllowConcurrency
+                ? new AsyncCommandWithCancellation<T>(asyncCommand)
+                : new AsyncLazyCommandWithCancellation<T>(asyncCommand);
         }
     }
 }

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncLazyCommand.cs

@@ -5,6 +5,7 @@ namespace UnityMvvmToolkit.UniTask.Interfaces
     public interface IBaseAsyncCommand
     {
         bool IsRunning { get; }
+        bool AllowConcurrency { get; set; }
         bool DisableOnExecution { get; set; }
 
         void Cancel();

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncLazyCommand.cs.meta

@@ -6,17 +6,24 @@ namespace UnityMvvmToolkit.UniTask.Internal
     using Interfaces;
     using System.Threading;
     using Cysharp.Threading.Tasks;
+    using System.Collections.Concurrent;
+    using System.Runtime.CompilerServices;
 
     internal class AsyncCommandWithCancellation<T> : BaseAsyncCommand, IAsyncCommand<T>
     {
         private readonly IAsyncCommand<T> _asyncCommand;
+        private readonly ConcurrentQueue<UniTask> _runningCommands;
+
         private CancellationTokenSource _cancellationTokenSource;
 
         public AsyncCommandWithCancellation(IAsyncCommand<T> asyncCommand) : base(null)
         {
             _asyncCommand = asyncCommand;
+            _runningCommands = new ConcurrentQueue<UniTask>();
         }
 
+        public override bool IsRunning { get; protected set; }
+
         public override bool DisableOnExecution
         {
             get => _asyncCommand.DisableOnExecution;
@@ -31,20 +38,35 @@ public override event EventHandler<bool> CanExecuteChanged
 
         public void Execute(T parameter)
         {
-            ExecuteAsync(parameter).Forget();
+            if (IsRunning)
+            {
+                TryEnqueueAsyncCommand(parameter, _cancellationTokenSource.Token);
+            }
+            else
+            {
+                ExecuteAsync(parameter).Forget();
+            }
         }
 
         public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationToken = default)
         {
-            _cancellationTokenSource?.Cancel();
-            _cancellationTokenSource = new CancellationTokenSource();
+            _cancellationTokenSource ??= new CancellationTokenSource();
 
             try
             {
-                await _asyncCommand.ExecuteAsync(parameter, _cancellationTokenSource.Token);
+                IsRunning = true;
+
+                TryEnqueueAsyncCommand(parameter, _cancellationTokenSource.Token);
+
+                while (_runningCommands.TryDequeue(out var asyncCommand))
+                {
+                    await asyncCommand;
+                }
             }
             finally
             {
+                IsRunning = false;
+
                 _cancellationTokenSource?.Dispose();
                 _cancellationTokenSource = null;
             }
@@ -54,6 +76,17 @@ public override void Cancel()
         {
             _cancellationTokenSource?.Cancel();
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void TryEnqueueAsyncCommand(T parameter, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
+            _runningCommands.Enqueue(_asyncCommand.ExecuteAsync(parameter, cancellationToken));
+        }
     }
 }
 

src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/BaseAsyncCommand.cs

@@ -6,17 +6,24 @@ namespace UnityMvvmToolkit.UniTask.Internal
     using Interfaces;
     using System.Threading;
     using Cysharp.Threading.Tasks;
+    using System.Collections.Concurrent;
+    using System.Runtime.CompilerServices;
 
     internal class AsyncCommandWithCancellation : BaseAsyncCommand, IAsyncCommand
     {
         private readonly IAsyncCommand _asyncCommand;
+        private readonly ConcurrentQueue<UniTask> _runningCommands;
+
         private CancellationTokenSource _cancellationTokenSource;
 
         public AsyncCommandWithCancellation(IAsyncCommand asyncCommand) : base(null)
         {
             _asyncCommand = asyncCommand;
+            _runningCommands = new ConcurrentQueue<UniTask>();
         }
 
+        public override bool IsRunning { get; protected set; }
+
         public override bool DisableOnExecution
         {
             get => _asyncCommand.DisableOnExecution;
@@ -31,20 +38,35 @@ public override event EventHandler<bool> CanExecuteChanged
 
         public void Execute()
         {
-            ExecuteAsync().Forget();
+            if (IsRunning)
+            {
+                TryEnqueueAsyncCommand(_cancellationTokenSource.Token);
+            }
+            else
+            {
+                ExecuteAsync().Forget();
+            }
         }
 
         public async UniTask ExecuteAsync(CancellationToken cancellationToken = default)
         {
-            _cancellationTokenSource?.Cancel();
-            _cancellationTokenSource = new CancellationTokenSource();
+            _cancellationTokenSource ??= new CancellationTokenSource();
 
             try
             {
-                await _asyncCommand.ExecuteAsync(_cancellationTokenSource.Token);
+                IsRunning = true;
+
+                TryEnqueueAsyncCommand(_cancellationTokenSource.Token);
+
+                while (_runningCommands.TryDequeue(out var asyncCommand))
+                {
+                    await asyncCommand;
+                }
             }
             finally
             {
+                IsRunning = false;
+
                 _cancellationTokenSource?.Dispose();
                 _cancellationTokenSource = null;
             }
@@ -54,6 +76,17 @@ public override void Cancel()
         {
             _cancellationTokenSource?.Cancel();
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void TryEnqueueAsyncCommand(CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
+            _runningCommands.Enqueue(_asyncCommand.ExecuteAsync(cancellationToken));
+        }
     }
 }