XAML CommandParameter and enum values

[hawkerm]

Feel like this may be a bug (or oversight), but I'm also not sure how to work around it...

Background: Came about as I was taking the WTS template for Settings Page which uses the ElementTheme XAML type in UWP and saves it as a property in the Settings ViewModel. I wanted to de-couple the UI from the ViewModel, as I have my MVVM bits in a .NET Standard library 😇; so I made my own ElementTheme enum to represent the same values:

public enum ElementTheme
{
    Default = 0,
    Light = 1,
    Dark = 2
}

This is exposed in a command in the view model like so:

    [RelayCommand]
    public async Task SwitchTheme(MyLib.ElementTheme newTheme)
    {
        ElementTheme = newTheme;
        await ThemeSelectorService.SetThemeAsync(newTheme);
    }

And then used directly in XAML here in the application layer:

                    <RadioButton
                        x:Uid="Settings_Theme_Light"
                        Command="{x:Bind ViewModel.SwitchThemeCommand}"
                        IsChecked="{x:Bind ViewModel.ElementTheme, Converter={StaticResource EnumToBooleanConverter}, ConverterParameter=Light, Mode=OneWay}"
                        FontSize="15"
                        GroupName="AppTheme">
                        <RadioButton.CommandParameter>
                            <models:ElementTheme>Light</models:ElementTheme> <!-- This used to be xaml: in the original WTS version as it directly used the XAML based enum version -->
                        </RadioButton.CommandParameter>
                    </RadioButton>

However, it seems like the enum is being converted by XAML or WinRT to an Int32 between the layers, and now I'm getting an exception from the AsyncRelayCommand that it is not a valid parameter type (even though it should be able to convert between the two):

System.ArgumentException
HResult=0x80070057
Message=Parameter "parameter" (object) cannot be of type System.Int32, as the command type requires an argument of type MyLib.ElementTheme.
Parameter name: parameter
Source=CommunityToolkit.Mvvm
StackTrace:
at CommunityToolkit.Mvvm.Input.RelayCommand`1.ThrowArgumentExceptionForInvalidCommandArgument(Object parameter) in /_/CommunityToolkit.Mvvm/Input/RelayCommand{T}.cs:line 170

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

Lines 167 to 170 in 9d1a525

	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);

Being called from here L271:

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

Lines 263 to 271 in 9d1a525

	public bool CanExecute(object? parameter)
	{
	// Special case, see RelayCommand<T>.CanExecute(object?) for more info
	if (parameter is null && default(T) is not null)
	{
	return false;
	}
	if (!RelayCommand<T>.TryGetCommandArgument(parameter, out T? result))

It's happening when the command is getting set by the generated xaml from the binding obj.Command = :

            public static void Set_Windows_UI_Xaml_Controls_Primitives_ButtonBase_Command(global::Windows.UI.Xaml.Controls.Primitives.ButtonBase obj, global::System.Windows.Input.ICommand value, string targetNullValue)
            {
                if (value == null && targetNullValue != null)
                {
                    value = (global::System.Windows.Input.ICommand) global::Windows.UI.Xaml.Markup.XamlBindingHelper.ConvertValue(typeof(global::System.Windows.Input.ICommand), targetNullValue);
                }
                obj.Command = value;
            }

Which somehow triggers a CanExecute call in the transition somewhere, I couldn't dig into that, but here's the CanExecute method in the stack from the ICommandToWinRTAdapter class:

		private bool CanExecute(object parameter)
		{
			ICommand _this = Unsafe.As<ICommand>(this);
			return _this.CanExecute(parameter);
		}

Call stack from there:

CommunityToolkit.Mvvm.dll!CommunityToolkit.Mvvm.Input.RelayCommand<MyLib.ElementTheme>.ThrowArgumentExceptionForInvalidCommandArgument(object parameter) Line 170	C#
CommunityToolkit.Mvvm.dll!CommunityToolkit.Mvvm.Input.AsyncRelayCommand<MyLib.ElementTheme>.CanExecute(object parameter) Line 271	C#
System.Runtime.WindowsRuntime.dll!System.Runtime.InteropServices.WindowsRuntime.ICommandToWinRTAdapter.CanExecute(object parameter) Line 39	C#
[Native to Managed Transition]	
[Managed to Native Transition]	
MyApp.exe!MyApp.Views.SettingsPage.XamlBindingSetters.Set_Windows_UI_Xaml_Controls_Primitives_ButtonBase_Command(Windows.UI.Xaml.Controls.Primitives.ButtonBase obj, System.Windows.Input.ICommand value, string targetNullValue) Line 36	C#

🤷‍♂️

[hawkerm]

Quickly tried using int as the parameter type and then casting back to strongly typed:

    [RelayCommand]
    public async Task SwitchTheme(int newTheme)
    {
        ElementTheme = (MyLib.ElementTheme)newTheme;
        await ThemeSelectorService.SetThemeAsync(ElementTheme);
    }

This feels dirty, but works for now. Would be nice to keep strong typing through-out though.

[michael-hawker]

This seems related to this platform issue filed here: microsoft/microsoft-ui-xaml#7633

[michael-hawker]

I have confirmed this is indeed a platform bug with UWP/XAML. I wrote a simple MarkupExtension and it provided the value and passed it correctly. I've posted that solution in that thread here: microsoft/microsoft-ui-xaml#7633 (comment)

[MarkupExtensionReturnType(ReturnType = typeof(object))]
public class EnumValueExtension : MarkupExtension
{
    public Type Type { get; set; }

    public string Member { get; set; }

    protected override object ProvideValue()
    {
        return Enum.Parse(Type, Member);
    }
}

<RadioButton Command="{x:Bind ViewModel.SwitchPaneOrientationCommand, Mode=OneWay}"
             CommandParameter="{helper:EnumValue Type=model:PaneOrientation,
                                                 Member=HorizontalPreviewTop}"/>