Add ArgumentException-s for invalid command arguments

Author: Sergio0694

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

@@ -262,13 +262,18 @@ public bool CanExecute(T? parameter)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool CanExecute(object? parameter)
     {
-        if (default(T) is not null &&
-            parameter is null)
+        // Special case, see RelayCommand<T>.CanExecute(object?) for more info
+        if (parameter is null && default(T) is not null)
         {
             return false;
         }
 
-        return CanExecute((T?)parameter);
+        if (!RelayCommand<T>.TryGetCommandArgument(parameter, out T? result))
+        {
+            RelayCommand<T>.ThrowArgumentExceptionForInvalidCommandArgument(parameter);
+        }
+
+        return CanExecute(result);
     }
 
     /// <inheritdoc/>
@@ -286,7 +291,12 @@ public void Execute(T? parameter)
     /// <inheritdoc/>
     public void Execute(object? parameter)
     {
-        Execute((T?)parameter);
+        if (!RelayCommand<T>.TryGetCommandArgument(parameter, out T? result))
+        {
+            RelayCommand<T>.ThrowArgumentExceptionForInvalidCommandArgument(parameter);
+        }
+
+        Execute(result);
     }
 
     /// <inheritdoc/>
@@ -322,7 +332,12 @@ public Task ExecuteAsync(T? parameter)
     /// <inheritdoc/>
     public Task ExecuteAsync(object? parameter)
     {
-        return ExecuteAsync((T?)parameter);
+        if (!RelayCommand<T>.TryGetCommandArgument(parameter, out T? result))
+        {
+            RelayCommand<T>.ThrowArgumentExceptionForInvalidCommandArgument(parameter);
+        }
+
+        return ExecuteAsync(result);
     }
 
     /// <inheritdoc/>

CommunityToolkit.Mvvm/Input/Interfaces/IAsyncRelayCommand.cs

@@ -63,6 +63,7 @@ public interface IAsyncRelayCommand : IRelayCommand, INotifyPropertyChanged
     /// </summary>
     /// <param name="parameter">The input parameter.</param>
     /// <returns>The <see cref="Task"/> representing the async operation being executed.</returns>
+    /// <exception cref="System.ArgumentException">Thrown if <paramref name="parameter"/> is incompatible with the underlying command implementation.</exception>
     Task ExecuteAsync(object? parameter);
 
     /// <summary>

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

@@ -6,6 +6,7 @@
 // more info in ThirdPartyNotices.txt in the root of the project.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace CommunityToolkit.Mvvm.Input;
@@ -81,13 +82,19 @@ public bool CanExecute(T? parameter)
     /// <inheritdoc/>
     public bool CanExecute(object? parameter)
     {
-        if (default(T) is not null &&
-            parameter is null)
+        // Special case a null value for a value type argument type.
+        // This ensures that no exceptions are thrown during initialization.
+        if (parameter is null && default(T) is not null)
         {
             return false;
         }
 
-        return CanExecute((T?)parameter);
+        if (!TryGetCommandArgument(parameter, out T? result))
+        {
+            ThrowArgumentExceptionForInvalidCommandArgument(parameter);
+        }
+
+        return CanExecute(result);
     }
 
     /// <inheritdoc/>
@@ -100,6 +107,66 @@ public void Execute(T? parameter)
     /// <inheritdoc/>
     public void Execute(object? parameter)
     {
-        Execute((T?)parameter);
+        if (!TryGetCommandArgument(parameter, out T? result))
+        {
+            ThrowArgumentExceptionForInvalidCommandArgument(parameter);
+        }
+
+        Execute(result);
+    }
+
+    /// <summary>
+    /// Tries to get a command argument of compatible type <typeparamref name="T"/> from an input <see cref="object"/>.
+    /// </summary>
+    /// <param name="parameter">The input parameter.</param>
+    /// <param name="result">The resulting <typeparamref name="T"/> value, if any.</param>
+    /// <returns>Whether or not a compatible command argument could be retrieved.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static bool TryGetCommandArgument(object? parameter, out T? result)
+    {
+        // If the argument is null and the default value of T is also null, then the
+        // argument is valid. T might be a reference type or a nullable value type.
+        if (parameter is null && default(T) is null)
+        {
+            result = default;
+
+            return true;
+        }
+
+        // Check if the argument is a T value, so either an instance of a type or a derived
+        // type of T is a reference type, an interface implementation if T is an interface,
+        // or a boxed value type in case T was a value type.
+        if (parameter is T argument)
+        {
+            result = argument;
+
+            return true;
+        }
+
+        result = default;
+
+        return false;
+    }
+
+    /// <summary>
+    /// Throws an <see cref="ArgumentException"/> if an invalid command argument is used.
+    /// </summary>
+    /// <param name="parameter">The input parameter.</param>
+    /// <exception cref="ArgumentException">Thrown with an error message to give info on the invalid parameter.</exception>
+    [DoesNotReturn]
+    internal static void ThrowArgumentExceptionForInvalidCommandArgument(object? parameter)
+    {
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static Exception GetException(object? parameter)
+        {
+            if (parameter is null)
+            {
+                return new ArgumentException($"Parameter \"{nameof(parameter)}\" (object) must not be null, as the command type requires an argument of type {typeof(T)}.", nameof(parameter));
+            }
+
+            return new ArgumentException($"Parameter \"{nameof(parameter)}\" (object) cannot be of type {parameter.GetType()}, as the command type requires an argument of type {typeof(T)}.", nameof(parameter));
+        }
+
+        throw GetException(parameter);
     }
 }