Improved nullability annotations in commands

Sergio0694 · Sergio0694 · commit 47f495c42ad0 · 2021-02-13T00:16:27.000+01:00
diff --git a/Microsoft.Toolkit.Mvvm/Input/AsyncRelayCommand.cs b/Microsoft.Toolkit.Mvvm/Input/AsyncRelayCommand.cs
@@ -122,7 +122,7 @@ private set
         }
 
         /// <inheritdoc/>
-        public bool CanBeCanceled => !(this.cancelableExecute is null) && IsRunning;
+        public bool CanBeCanceled => this.cancelableExecute is not null && IsRunning;
 
         /// <inheritdoc/>
         public bool IsCancellationRequested => this.cancellationTokenSource?.IsCancellationRequested == true;
@@ -155,7 +155,7 @@ public Task ExecuteAsync(object? parameter)
             if (CanExecute(parameter))
             {
                 // Non cancelable command delegate
-                if (!(this.execute is null))
+                if (this.execute is not null)
                 {
                     return ExecutionTask = this.execute();
                 }
diff --git a/Microsoft.Toolkit.Mvvm/Input/AsyncRelayCommand{T}.cs b/Microsoft.Toolkit.Mvvm/Input/AsyncRelayCommand{T}.cs
@@ -19,17 +19,17 @@ public sealed class AsyncRelayCommand<T> : ObservableObject, IAsyncRelayCommand<
         /// <summary>
         /// The <see cref="Func{TResult}"/> to invoke when <see cref="Execute(T)"/> is used.
         /// </summary>
-        private readonly Func<T, Task>? execute;
+        private readonly Func<T?, Task>? execute;
 
         /// <summary>
         /// The cancelable <see cref="Func{T1,T2,TResult}"/> to invoke when <see cref="Execute(object?)"/> is used.
         /// </summary>
-        private readonly Func<T, CancellationToken, Task>? cancelableExecute;
+        private readonly Func<T?, CancellationToken, Task>? cancelableExecute;
 
         /// <summary>
         /// The optional action to invoke when <see cref="CanExecute(T)"/> is used.
         /// </summary>
-        private readonly Predicate<T>? canExecute;
+        private readonly Predicate<T?>? canExecute;
 
         /// <summary>
         /// The <see cref="CancellationTokenSource"/> instance to use to cancel <see cref="cancelableExecute"/>.
@@ -44,7 +44,7 @@ public sealed class AsyncRelayCommand<T> : ObservableObject, IAsyncRelayCommand<
         /// </summary>
         /// <param name="execute">The execution logic.</param>
         /// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>
-        public AsyncRelayCommand(Func<T, Task> execute)
+        public AsyncRelayCommand(Func<T?, Task> execute)
         {
             this.execute = execute;
         }
@@ -54,7 +54,7 @@ public AsyncRelayCommand(Func<T, Task> execute)
         /// </summary>
         /// <param name="cancelableExecute">The cancelable execution logic.</param>
         /// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>
-        public AsyncRelayCommand(Func<T, CancellationToken, Task> cancelableExecute)
+        public AsyncRelayCommand(Func<T?, CancellationToken, Task> cancelableExecute)
         {
             this.cancelableExecute = cancelableExecute;
         }
@@ -65,7 +65,7 @@ public AsyncRelayCommand(Func<T, CancellationToken, Task> cancelableExecute)
         /// <param name="execute">The execution logic.</param>
         /// <param name="canExecute">The execution status logic.</param>
         /// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>
-        public AsyncRelayCommand(Func<T, Task> execute, Predicate<T> canExecute)
+        public AsyncRelayCommand(Func<T?, Task> execute, Predicate<T?> canExecute)
         {
             this.execute = execute;
             this.canExecute = canExecute;
@@ -77,7 +77,7 @@ public AsyncRelayCommand(Func<T, Task> execute, Predicate<T> canExecute)
         /// <param name="cancelableExecute">The cancelable execution logic.</param>
         /// <param name="canExecute">The execution status logic.</param>
         /// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>
-        public AsyncRelayCommand(Func<T, CancellationToken, Task> cancelableExecute, Predicate<T> canExecute)
+        public AsyncRelayCommand(Func<T?, CancellationToken, Task> cancelableExecute, Predicate<T?> canExecute)
         {
             this.cancelableExecute = cancelableExecute;
             this.canExecute = canExecute;
@@ -106,7 +106,7 @@ private set
         }
 
         /// <inheritdoc/>
-        public bool CanBeCanceled => !(this.cancelableExecute is null) && IsRunning;
+        public bool CanBeCanceled => this.cancelableExecute is not null && IsRunning;
 
         /// <inheritdoc/>
         public bool IsCancellationRequested => this.cancellationTokenSource?.IsCancellationRequested == true;
@@ -122,7 +122,7 @@ public void NotifyCanExecuteChanged()
 
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool CanExecute(T parameter)
+        public bool CanExecute(T? parameter)
         {
             return this.canExecute?.Invoke(parameter) != false;
         }
@@ -138,29 +138,29 @@ parameter is null &&
                 return true;
             }
 
-            return CanExecute((T)parameter!);
+            return CanExecute((T?)parameter);
         }
 
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Execute(T parameter)
+        public void Execute(T? parameter)
         {
             ExecuteAsync(parameter);
         }
 
         /// <inheritdoc/>
         public void Execute(object? parameter)
         {
-            ExecuteAsync((T)parameter!);
+            ExecuteAsync((T?)parameter);
         }
 
         /// <inheritdoc/>
-        public Task ExecuteAsync(T parameter)
+        public Task ExecuteAsync(T? parameter)
         {
             if (CanExecute(parameter))
             {
                 // Non cancelable command delegate
-                if (!(this.execute is null))
+                if (this.execute is not null)
                 {
                     return ExecutionTask = this.execute(parameter);
                 }
@@ -182,7 +182,7 @@ public Task ExecuteAsync(T parameter)
         /// <inheritdoc/>
         public Task ExecuteAsync(object? parameter)
         {
-            return ExecuteAsync((T)parameter!);
+            return ExecuteAsync((T?)parameter);
         }
 
         /// <inheritdoc/>
diff --git a/Microsoft.Toolkit.Mvvm/Input/Interfaces/IAsyncRelayCommand{T}.cs b/Microsoft.Toolkit.Mvvm/Input/Interfaces/IAsyncRelayCommand{T}.cs
@@ -18,6 +18,6 @@ public interface IAsyncRelayCommand<in T> : IAsyncRelayCommand, IRelayCommand<T>
         /// </summary>
         /// <param name="parameter">The input parameter.</param>
         /// <returns>The <see cref="Task"/> representing the async operation being executed.</returns>
-        Task ExecuteAsync(T parameter);
+        Task ExecuteAsync(T? parameter);
     }
 }
diff --git a/Microsoft.Toolkit.Mvvm/Input/Interfaces/IRelayCommand{T}.cs b/Microsoft.Toolkit.Mvvm/Input/Interfaces/IRelayCommand{T}.cs
@@ -18,13 +18,13 @@ public interface IRelayCommand<in T> : IRelayCommand
         /// <param name="parameter">The input parameter.</param>
         /// <returns>Whether or not the current command can be executed.</returns>
         /// <remarks>Use this overload to avoid boxing, if <typeparamref name="T"/> is a value type.</remarks>
-        bool CanExecute(T parameter);
+        bool CanExecute(T? parameter);
 
         /// <summary>
         /// Provides a strongly-typed variant of <see cref="ICommand.Execute(object)"/>.
         /// </summary>
         /// <param name="parameter">The input parameter.</param>
         /// <remarks>Use this overload to avoid boxing, if <typeparamref name="T"/> is a value type.</remarks>
-        void Execute(T parameter);
+        void Execute(T? parameter);
     }
 }
diff --git a/Microsoft.Toolkit.Mvvm/Input/RelayCommand{T}.cs b/Microsoft.Toolkit.Mvvm/Input/RelayCommand{T}.cs
@@ -24,12 +24,12 @@ public sealed class RelayCommand<T> : IRelayCommand<T>
         /// <summary>
         /// The <see cref="Action"/> to invoke when <see cref="Execute(T)"/> is used.
         /// </summary>
-        private readonly Action<T> execute;
+        private readonly Action<T?> execute;
 
         /// <summary>
         /// The optional action to invoke when <see cref="CanExecute(T)"/> is used.
         /// </summary>
-        private readonly Predicate<T>? canExecute;
+        private readonly Predicate<T?>? canExecute;
 
         /// <inheritdoc/>
         public event EventHandler? CanExecuteChanged;
@@ -43,7 +43,7 @@ public sealed class RelayCommand<T> : IRelayCommand<T>
         /// nullable <see cref="object"/> parameter, it is recommended that if <typeparamref name="T"/> is a reference type,
         /// you should always declare it as nullable, and to always perform checks within <paramref name="execute"/>.
         /// </remarks>
-        public RelayCommand(Action<T> execute)
+        public RelayCommand(Action<T?> execute)
         {
             this.execute = execute;
         }
@@ -54,7 +54,7 @@ public RelayCommand(Action<T> execute)
         /// <param name="execute">The execution logic.</param>
         /// <param name="canExecute">The execution status logic.</param>
         /// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>
-        public RelayCommand(Action<T> execute, Predicate<T> canExecute)
+        public RelayCommand(Action<T?> execute, Predicate<T?> canExecute)
         {
             this.execute = execute;
             this.canExecute = canExecute;
@@ -68,7 +68,7 @@ public void NotifyCanExecuteChanged()
 
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool CanExecute(T parameter)
+        public bool CanExecute(T? parameter)
         {
             return this.canExecute?.Invoke(parameter) != false;
         }
@@ -83,12 +83,12 @@ parameter is null &&
                 return true;
             }
 
-            return CanExecute((T)parameter!);
+            return CanExecute((T?)parameter);
         }
 
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Execute(T parameter)
+        public void Execute(T? parameter)
         {
             if (CanExecute(parameter))
             {
@@ -99,7 +99,7 @@ public void Execute(T parameter)
         /// <inheritdoc/>
         public void Execute(object? parameter)
         {
-            Execute((T)parameter!);
+            Execute((T?)parameter);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ private set`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`/// <inheritdoc/>`
`125`		`- public bool CanBeCanceled => !(this.cancelableExecute is null) && IsRunning;`
	`125`	`+ public bool CanBeCanceled => this.cancelableExecute is not null && IsRunning;`
`126`	`126`
`127`	`127`	`/// <inheritdoc/>`
`128`	`128`	`public bool IsCancellationRequested => this.cancellationTokenSource?.IsCancellationRequested == true;`
`@@ -155,7 +155,7 @@ public Task ExecuteAsync(object? parameter)`
`155`	`155`	`if (CanExecute(parameter))`
`156`	`156`	`{`
`157`	`157`	`// Non cancelable command delegate`
`158`		`- if (!(this.execute is null))`
	`158`	`+ if (this.execute is not null)`
`159`	`159`	`{`
`160`	`160`	`return ExecutionTask = this.execute();`
`161`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,17 +19,17 @@ public sealed class AsyncRelayCommand<T> : ObservableObject, IAsyncRelayCommand<`
`19`	`19`	`/// <summary>`
`20`	`20`	`/// The <see cref="Func{TResult}"/> to invoke when <see cref="Execute(T)"/> is used.`
`21`	`21`	`/// </summary>`
`22`		`- private readonly Func<T, Task>? execute;`
	`22`	`+ private readonly Func<T?, Task>? execute;`
`23`	`23`
`24`	`24`	`/// <summary>`
`25`	`25`	`/// The cancelable <see cref="Func{T1,T2,TResult}"/> to invoke when <see cref="Execute(object?)"/> is used.`
`26`	`26`	`/// </summary>`
`27`		`- private readonly Func<T, CancellationToken, Task>? cancelableExecute;`
	`27`	`+ private readonly Func<T?, CancellationToken, Task>? cancelableExecute;`
`28`	`28`
`29`	`29`	`/// <summary>`
`30`	`30`	`/// The optional action to invoke when <see cref="CanExecute(T)"/> is used.`
`31`	`31`	`/// </summary>`
`32`		`- private readonly Predicate<T>? canExecute;`
	`32`	`+ private readonly Predicate<T?>? canExecute;`
`33`	`33`
`34`	`34`	`/// <summary>`
`35`	`35`	`/// The <see cref="CancellationTokenSource"/> instance to use to cancel <see cref="cancelableExecute"/>.`
`@@ -44,7 +44,7 @@ public sealed class AsyncRelayCommand<T> : ObservableObject, IAsyncRelayCommand<`
`44`	`44`	`/// </summary>`
`45`	`45`	`/// <param name="execute">The execution logic.</param>`
`46`	`46`	`/// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>`
`47`		`- public AsyncRelayCommand(Func<T, Task> execute)`
	`47`	`+ public AsyncRelayCommand(Func<T?, Task> execute)`
`48`	`48`	`{`
`49`	`49`	`this.execute = execute;`
`50`	`50`	`}`
`@@ -54,7 +54,7 @@ public AsyncRelayCommand(Func<T, Task> execute)`
`54`	`54`	`/// </summary>`
`55`	`55`	`/// <param name="cancelableExecute">The cancelable execution logic.</param>`
`56`	`56`	`/// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>`
`57`		`- public AsyncRelayCommand(Func<T, CancellationToken, Task> cancelableExecute)`
	`57`	`+ public AsyncRelayCommand(Func<T?, CancellationToken, Task> cancelableExecute)`
`58`	`58`	`{`
`59`	`59`	`this.cancelableExecute = cancelableExecute;`
`60`	`60`	`}`
`@@ -65,7 +65,7 @@ public AsyncRelayCommand(Func<T, CancellationToken, Task> cancelableExecute)`
`65`	`65`	`/// <param name="execute">The execution logic.</param>`
`66`	`66`	`/// <param name="canExecute">The execution status logic.</param>`
`67`	`67`	`/// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>`
`68`		`- public AsyncRelayCommand(Func<T, Task> execute, Predicate<T> canExecute)`
	`68`	`+ public AsyncRelayCommand(Func<T?, Task> execute, Predicate<T?> canExecute)`
`69`	`69`	`{`
`70`	`70`	`this.execute = execute;`
`71`	`71`	`this.canExecute = canExecute;`
`@@ -77,7 +77,7 @@ public AsyncRelayCommand(Func<T, Task> execute, Predicate<T> canExecute)`
`77`	`77`	`/// <param name="cancelableExecute">The cancelable execution logic.</param>`
`78`	`78`	`/// <param name="canExecute">The execution status logic.</param>`
`79`	`79`	`/// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>`
`80`		`- public AsyncRelayCommand(Func<T, CancellationToken, Task> cancelableExecute, Predicate<T> canExecute)`
	`80`	`+ public AsyncRelayCommand(Func<T?, CancellationToken, Task> cancelableExecute, Predicate<T?> canExecute)`
`81`	`81`	`{`
`82`	`82`	`this.cancelableExecute = cancelableExecute;`
`83`	`83`	`this.canExecute = canExecute;`
`@@ -106,7 +106,7 @@ private set`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`/// <inheritdoc/>`
`109`		`- public bool CanBeCanceled => !(this.cancelableExecute is null) && IsRunning;`
	`109`	`+ public bool CanBeCanceled => this.cancelableExecute is not null && IsRunning;`
`110`	`110`
`111`	`111`	`/// <inheritdoc/>`
`112`	`112`	`public bool IsCancellationRequested => this.cancellationTokenSource?.IsCancellationRequested == true;`
`@@ -122,7 +122,7 @@ public void NotifyCanExecuteChanged()`
`122`	`122`
`123`	`123`	`/// <inheritdoc/>`
`124`	`124`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`125`		`- public bool CanExecute(T parameter)`
	`125`	`+ public bool CanExecute(T? parameter)`
`126`	`126`	`{`
`127`	`127`	`return this.canExecute?.Invoke(parameter) != false;`
`128`	`128`	`}`
`@@ -138,29 +138,29 @@ parameter is null &&`
`138`	`138`	`return true;`
`139`	`139`	`}`
`140`	`140`
`141`		`- return CanExecute((T)parameter!);`
	`141`	`+ return CanExecute((T?)parameter);`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`/// <inheritdoc/>`
`145`	`145`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`146`		`- public void Execute(T parameter)`
	`146`	`+ public void Execute(T? parameter)`
`147`	`147`	`{`
`148`	`148`	`ExecuteAsync(parameter);`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`/// <inheritdoc/>`
`152`	`152`	`public void Execute(object? parameter)`
`153`	`153`	`{`
`154`		`- ExecuteAsync((T)parameter!);`
	`154`	`+ ExecuteAsync((T?)parameter);`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`/// <inheritdoc/>`
`158`		`- public Task ExecuteAsync(T parameter)`
	`158`	`+ public Task ExecuteAsync(T? parameter)`
`159`	`159`	`{`
`160`	`160`	`if (CanExecute(parameter))`
`161`	`161`	`{`
`162`	`162`	`// Non cancelable command delegate`
`163`		`- if (!(this.execute is null))`
	`163`	`+ if (this.execute is not null)`
`164`	`164`	`{`
`165`	`165`	`return ExecutionTask = this.execute(parameter);`
`166`	`166`	`}`
`@@ -182,7 +182,7 @@ public Task ExecuteAsync(T parameter)`
`182`	`182`	`/// <inheritdoc/>`
`183`	`183`	`public Task ExecuteAsync(object? parameter)`
`184`	`184`	`{`
`185`		`- return ExecuteAsync((T)parameter!);`
	`185`	`+ return ExecuteAsync((T?)parameter);`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`/// <inheritdoc/>`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,6 @@ public interface IAsyncRelayCommand<in T> : IAsyncRelayCommand, IRelayCommand<T>`
`18`	`18`	`/// </summary>`
`19`	`19`	`/// <param name="parameter">The input parameter.</param>`
`20`	`20`	`/// <returns>The <see cref="Task"/> representing the async operation being executed.</returns>`
`21`		`- Task ExecuteAsync(T parameter);`
	`21`	`+ Task ExecuteAsync(T? parameter);`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,12 +24,12 @@ public sealed class RelayCommand<T> : IRelayCommand<T>`
`24`	`24`	`/// <summary>`
`25`	`25`	`/// The <see cref="Action"/> to invoke when <see cref="Execute(T)"/> is used.`
`26`	`26`	`/// </summary>`
`27`		`- private readonly Action<T> execute;`
	`27`	`+ private readonly Action<T?> execute;`
`28`	`28`
`29`	`29`	`/// <summary>`
`30`	`30`	`/// The optional action to invoke when <see cref="CanExecute(T)"/> is used.`
`31`	`31`	`/// </summary>`
`32`		`- private readonly Predicate<T>? canExecute;`
	`32`	`+ private readonly Predicate<T?>? canExecute;`
`33`	`33`
`34`	`34`	`/// <inheritdoc/>`
`35`	`35`	`public event EventHandler? CanExecuteChanged;`
`@@ -43,7 +43,7 @@ public sealed class RelayCommand<T> : IRelayCommand<T>`
`43`	`43`	`/// nullable <see cref="object"/> parameter, it is recommended that if <typeparamref name="T"/> is a reference type,`
`44`	`44`	`/// you should always declare it as nullable, and to always perform checks within <paramref name="execute"/>.`
`45`	`45`	`/// </remarks>`
`46`		`- public RelayCommand(Action<T> execute)`
	`46`	`+ public RelayCommand(Action<T?> execute)`
`47`	`47`	`{`
`48`	`48`	`this.execute = execute;`
`49`	`49`	`}`
`@@ -54,7 +54,7 @@ public RelayCommand(Action<T> execute)`
`54`	`54`	`/// <param name="execute">The execution logic.</param>`
`55`	`55`	`/// <param name="canExecute">The execution status logic.</param>`
`56`	`56`	`/// <remarks>See notes in <see cref="RelayCommand{T}(Action{T})"/>.</remarks>`
`57`		`- public RelayCommand(Action<T> execute, Predicate<T> canExecute)`
	`57`	`+ public RelayCommand(Action<T?> execute, Predicate<T?> canExecute)`
`58`	`58`	`{`
`59`	`59`	`this.execute = execute;`
`60`	`60`	`this.canExecute = canExecute;`
`@@ -68,7 +68,7 @@ public void NotifyCanExecuteChanged()`
`68`	`68`
`69`	`69`	`/// <inheritdoc/>`
`70`	`70`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`71`		`- public bool CanExecute(T parameter)`
	`71`	`+ public bool CanExecute(T? parameter)`
`72`	`72`	`{`
`73`	`73`	`return this.canExecute?.Invoke(parameter) != false;`
`74`	`74`	`}`
`@@ -83,12 +83,12 @@ parameter is null &&`
`83`	`83`	`return true;`
`84`	`84`	`}`
`85`	`85`
`86`		`- return CanExecute((T)parameter!);`
	`86`	`+ return CanExecute((T?)parameter);`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`/// <inheritdoc/>`
`90`	`90`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`91`		`- public void Execute(T parameter)`
	`91`	`+ public void Execute(T? parameter)`
`92`	`92`	`{`
`93`	`93`	`if (CanExecute(parameter))`
`94`	`94`	`{`
`@@ -99,7 +99,7 @@ public void Execute(T parameter)`
`99`	`99`	`/// <inheritdoc/>`
`100`	`100`	`public void Execute(object? parameter)`
`101`	`101`	`{`
`102`		`- Execute((T)parameter!);`
	`102`	`+ Execute((T?)parameter);`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`	`}`