Close #5. Make async command IsRunning observable.

ChebanovDD · ChebanovDD · commit f0c575b53e01 · 2023-05-04T15:25:45.000+08:00
diff --git a/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncCommand.T.cs b/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncCommand.T.cs
@@ -18,7 +18,7 @@ public AsyncCommand(Func<T, CancellationToken, UniTask> action, Func<bool> canEx
 
         public void Execute(T parameter)
         {
-            if (IsRunning && AllowConcurrency == false)
+            if (IsCommandRunning && AllowConcurrency == false)
             {
                 return;
             }
@@ -30,12 +30,13 @@ public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationTok
         {
             try
             {
-                IsRunning = true;
+                SetCommandRunning(true);
+
                 await _action(parameter, cancellationToken);
             }
             finally
             {
-                IsRunning = false;
+                SetCommandRunning(false);
             }
         }
     }
diff --git a/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncCommand.cs b/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/AsyncCommand.cs
@@ -18,7 +18,7 @@ public AsyncCommand(Func<CancellationToken, UniTask> action, Func<bool> canExecu
 
         public void Execute()
         {
-            if (IsRunning && AllowConcurrency == false)
+            if (IsCommandRunning && AllowConcurrency == false)
             {
                 return;
             }
@@ -30,12 +30,13 @@ public async UniTask ExecuteAsync(CancellationToken cancellationToken = default)
         {
             try
             {
-                IsRunning = true;
+                SetCommandRunning(true);
+
                 await _action(cancellationToken);
             }
             finally
             {
-                IsRunning = false;
+                SetCommandRunning(false);
             }
         }
     }
diff --git a/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/BaseAsyncCommand.cs b/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/BaseAsyncCommand.cs
@@ -7,29 +7,24 @@ namespace UnityMvvmToolkit.UniTask
     using Interfaces;
     using Extensions;
     using System.Runtime.CompilerServices;
+    using UnityMvvmToolkit.Core.Interfaces;
 
     public abstract class BaseAsyncCommand : BaseCommand, IBaseAsyncCommand
     {
-        private bool _isRunning;
+        private readonly IProperty<bool> _isRunning;
 
         protected BaseAsyncCommand(Func<bool> canExecute) : base(canExecute)
         {
-        }
-
-        public virtual bool IsRunning
-        {
-            get => _isRunning;
-            protected set
-            {
-                _isRunning = value;
-                RaiseCanExecuteChanged();
-            }
+            _isRunning = new Property<bool>();
         }
 
         public bool AllowConcurrency { get; set; }
-
         public virtual bool DisableOnExecution { get; set; }
 
+        public IReadOnlyProperty<bool> IsRunning => _isRunning;
+
+        protected bool IsCommandRunning { get; private set; }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override bool CanExecute()
         {
@@ -38,14 +33,28 @@ public override bool CanExecute()
                 return base.CanExecute();
             }
 
-            return IsRunning == false && base.CanExecute();
+            return IsCommandRunning == false && base.CanExecute();
         }
 
         public virtual void Cancel()
         {
             throw new InvalidOperationException(
                 $"To make the 'AsyncCommand' cancelable, use '{nameof(AsyncCommandExtensions.WithCancellation)}' extension.");
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void SetCommandRunning(bool isRunning)
+        {
+            _isRunning.Value = isRunning;
+
+            if (IsCommandRunning == isRunning)
+            {
+                return;
+            }
+
+            IsCommandRunning = isRunning;
+            RaiseCanExecuteChanged();
+        }
     }
 }
 
diff --git a/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Interfaces/IBaseAsyncCommand.cs b/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Interfaces/IBaseAsyncCommand.cs
@@ -2,12 +2,15 @@
 
 namespace UnityMvvmToolkit.UniTask.Interfaces
 {
+    using UnityMvvmToolkit.Core.Interfaces;
+
     public interface IBaseAsyncCommand
     {
-        bool IsRunning { get; }
         bool AllowConcurrency { get; set; }
         bool DisableOnExecution { get; set; }
 
+        IReadOnlyProperty<bool> IsRunning { get; }
+
         void Cancel();
     }
 }
diff --git a/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Internal/AsyncCommandWithCancellation.T.cs b/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Internal/AsyncCommandWithCancellation.T.cs
@@ -22,8 +22,6 @@ public AsyncCommandWithCancellation(IAsyncCommand<T> asyncCommand) : base(null)
             _runningCommands = new ConcurrentQueue<UniTask>();
         }
 
-        public override bool IsRunning { get; protected set; }
-
         public override bool DisableOnExecution
         {
             get => _asyncCommand.DisableOnExecution;
@@ -38,7 +36,7 @@ public override event EventHandler<bool> CanExecuteChanged
 
         public void Execute(T parameter)
         {
-            if (IsRunning)
+            if (IsCommandRunning)
             {
                 TryEnqueueAsyncCommand(parameter, _cancellationTokenSource.Token);
             }
@@ -54,7 +52,7 @@ public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationTok
 
             try
             {
-                IsRunning = true;
+                SetCommandRunning(true);
 
                 TryEnqueueAsyncCommand(parameter, _cancellationTokenSource.Token);
 
@@ -65,7 +63,7 @@ public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationTok
             }
             finally
             {
-                IsRunning = false;
+                SetCommandRunning(false);
 
                 _cancellationTokenSource?.Dispose();
                 _cancellationTokenSource = null;
diff --git a/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Internal/AsyncCommandWithCancellation.cs b/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Internal/AsyncCommandWithCancellation.cs
@@ -22,8 +22,6 @@ public AsyncCommandWithCancellation(IAsyncCommand asyncCommand) : base(null)
             _runningCommands = new ConcurrentQueue<UniTask>();
         }
 
-        public override bool IsRunning { get; protected set; }
-
         public override bool DisableOnExecution
         {
             get => _asyncCommand.DisableOnExecution;
@@ -38,7 +36,7 @@ public override event EventHandler<bool> CanExecuteChanged
 
         public void Execute()
         {
-            if (IsRunning)
+            if (IsCommandRunning)
             {
                 TryEnqueueAsyncCommand(_cancellationTokenSource.Token);
             }
@@ -54,7 +52,7 @@ public async UniTask ExecuteAsync(CancellationToken cancellationToken = default)
 
             try
             {
-                IsRunning = true;
+                SetCommandRunning(true);
 
                 TryEnqueueAsyncCommand(_cancellationTokenSource.Token);
 
@@ -65,7 +63,7 @@ public async UniTask ExecuteAsync(CancellationToken cancellationToken = default)
             }
             finally
             {
-                IsRunning = false;
+                SetCommandRunning(false);
 
                 _cancellationTokenSource?.Dispose();
                 _cancellationTokenSource = null;
diff --git a/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Internal/AsyncLazyCommandWithCancellation.T.cs b/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Internal/AsyncLazyCommandWithCancellation.T.cs
@@ -17,8 +17,6 @@ public AsyncLazyCommandWithCancellation(IAsyncCommand<T> asyncCommand) : base(nu
             _asyncCommand = asyncCommand;
         }
 
-        public override bool IsRunning => _asyncCommand.IsRunning;
-
         public override bool DisableOnExecution
         {
             get => _asyncCommand.DisableOnExecution;
@@ -33,7 +31,7 @@ public override event EventHandler<bool> CanExecuteChanged
 
         public void Execute(T parameter)
         {
-            if (IsRunning)
+            if (IsCommandRunning)
             {
                 return;
             }
@@ -47,10 +45,14 @@ public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationTok
 
             try
             {
+                SetCommandRunning(true);
+
                 await _asyncCommand.ExecuteAsync(parameter, _cancellationTokenSource.Token);
             }
             finally
             {
+                SetCommandRunning(false);
+
                 _cancellationTokenSource?.Dispose();
                 _cancellationTokenSource = null;
             }
diff --git a/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Internal/AsyncLazyCommandWithCancellation.cs b/src/UnityMvvmToolkit.UnityPackage/Assets/Plugins/UnityMvvmToolkit/Runtime/External/UniTask/Internal/AsyncLazyCommandWithCancellation.cs
@@ -17,8 +17,6 @@ public AsyncLazyCommandWithCancellation(IAsyncCommand asyncCommand) : base(null)
             _asyncCommand = asyncCommand;
         }
 
-        public override bool IsRunning => _asyncCommand.IsRunning;
-
         public override bool DisableOnExecution
         {
             get => _asyncCommand.DisableOnExecution;
@@ -33,7 +31,7 @@ public override event EventHandler<bool> CanExecuteChanged
 
         public void Execute()
         {
-            if (IsRunning)
+            if (IsCommandRunning)
             {
                 return;
             }
@@ -47,10 +45,14 @@ public async UniTask ExecuteAsync(CancellationToken cancellationToken = default)
 
             try
             {
+                SetCommandRunning(true);
+
                 await _asyncCommand.ExecuteAsync(_cancellationTokenSource.Token);
             }
             finally
             {
+                SetCommandRunning(false);
+
                 _cancellationTokenSource?.Dispose();
                 _cancellationTokenSource = null;
             }

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public AsyncCommand(Func<T, CancellationToken, UniTask> action, Func<bool> canEx`
`18`	`18`
`19`	`19`	`public void Execute(T parameter)`
`20`	`20`	`{`
`21`		`- if (IsRunning && AllowConcurrency == false)`
	`21`	`+ if (IsCommandRunning && AllowConcurrency == false)`
`22`	`22`	`{`
`23`	`23`	`return;`
`24`	`24`	`}`
`@@ -30,12 +30,13 @@ public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationTok`
`30`	`30`	`{`
`31`	`31`	`try`
`32`	`32`	`{`
`33`		`- IsRunning = true;`
	`33`	`+ SetCommandRunning(true);`
	`34`	`+`
`34`	`35`	`await _action(parameter, cancellationToken);`
`35`	`36`	`}`
`36`	`37`	`finally`
`37`	`38`	`{`
`38`		`- IsRunning = false;`
	`39`	`+ SetCommandRunning(false);`
`39`	`40`	`}`
`40`	`41`	`}`
`41`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,12 +2,15 @@`
`2`	`2`
`3`	`3`	`namespace UnityMvvmToolkit.UniTask.Interfaces`
`4`	`4`	`{`
	`5`	`+ using UnityMvvmToolkit.Core.Interfaces;`
	`6`	`+`
`5`	`7`	`public interface IBaseAsyncCommand`
`6`	`8`	`{`
`7`		`- bool IsRunning { get; }`
`8`	`9`	`bool AllowConcurrency { get; set; }`
`9`	`10`	`bool DisableOnExecution { get; set; }`
`10`	`11`
	`12`	`+ IReadOnlyProperty<bool> IsRunning { get; }`
	`13`	`+`
`11`	`14`	`void Cancel();`
`12`	`15`	`}`
`13`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,6 @@ public AsyncCommandWithCancellation(IAsyncCommand<T> asyncCommand) : base(null)`
`22`	`22`	`_runningCommands = new ConcurrentQueue<UniTask>();`
`23`	`23`	`}`
`24`	`24`
`25`		`- public override bool IsRunning { get; protected set; }`
`26`		`-`
`27`	`25`	`public override bool DisableOnExecution`
`28`	`26`	`{`
`29`	`27`	`get => _asyncCommand.DisableOnExecution;`
`@@ -38,7 +36,7 @@ public override event EventHandler<bool> CanExecuteChanged`
`38`	`36`
`39`	`37`	`public void Execute(T parameter)`
`40`	`38`	`{`
`41`		`- if (IsRunning)`
	`39`	`+ if (IsCommandRunning)`
`42`	`40`	`{`
`43`	`41`	`TryEnqueueAsyncCommand(parameter, _cancellationTokenSource.Token);`
`44`	`42`	`}`
`@@ -54,7 +52,7 @@ public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationTok`
`54`	`52`
`55`	`53`	`try`
`56`	`54`	`{`
`57`		`- IsRunning = true;`
	`55`	`+ SetCommandRunning(true);`
`58`	`56`
`59`	`57`	`TryEnqueueAsyncCommand(parameter, _cancellationTokenSource.Token);`
`60`	`58`
`@@ -65,7 +63,7 @@ public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationTok`
`65`	`63`	`}`
`66`	`64`	`finally`
`67`	`65`	`{`
`68`		`- IsRunning = false;`
	`66`	`+ SetCommandRunning(false);`
`69`	`67`
`70`	`68`	`_cancellationTokenSource?.Dispose();`
`71`	`69`	`_cancellationTokenSource = null;`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,6 @@ public AsyncLazyCommandWithCancellation(IAsyncCommand<T> asyncCommand) : base(nu`
`17`	`17`	`_asyncCommand = asyncCommand;`
`18`	`18`	`}`
`19`	`19`
`20`		`- public override bool IsRunning => _asyncCommand.IsRunning;`
`21`		`-`
`22`	`20`	`public override bool DisableOnExecution`
`23`	`21`	`{`
`24`	`22`	`get => _asyncCommand.DisableOnExecution;`
`@@ -33,7 +31,7 @@ public override event EventHandler<bool> CanExecuteChanged`
`33`	`31`
`34`	`32`	`public void Execute(T parameter)`
`35`	`33`	`{`
`36`		`- if (IsRunning)`
	`34`	`+ if (IsCommandRunning)`
`37`	`35`	`{`
`38`	`36`	`return;`
`39`	`37`	`}`
`@@ -47,10 +45,14 @@ public async UniTask ExecuteAsync(T parameter, CancellationToken cancellationTok`
`47`	`45`
`48`	`46`	`try`
`49`	`47`	`{`
	`48`	`+ SetCommandRunning(true);`
	`49`	`+`
`50`	`50`	`await _asyncCommand.ExecuteAsync(parameter, _cancellationTokenSource.Token);`
`51`	`51`	`}`
`52`	`52`	`finally`
`53`	`53`	`{`
	`54`	`+ SetCommandRunning(false);`
	`55`	`+`
`54`	`56`	`_cancellationTokenSource?.Dispose();`
`55`	`57`	`_cancellationTokenSource = null;`
`56`	`58`	`}`