NotifyCanExecuteChangedFor generated code raises exception

[avsteele]

If I add a NotifyCanExecuteChangedFor attribute to a property, I can observe exceptions of the type The calling thread cannot access this object because a different thread owns it. These occur when the generated code reaches the line that calls NotifyCanExecuteChanged() as shown below.

I start with a simple WPF template:

    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            DataContext = new MainWindowVM();
        }
    }

and

    [INotifyPropertyChanged]
    public partial class MainWindowVM
    {
        public MainWindowVM()
        {
            System.Timers.Timer timer = new System.Timers.Timer(1000);
            timer.Elapsed += Timer_Elapsed;
            timer.AutoReset = true;
            timer.Start();
        }

        private void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
        {
            Counter = (Counter + 200)%3000;
        }

        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(DoThingCommand))]
        private int counter;

        [RelayCommand(CanExecute = nameof(CanRunDoThing), IncludeCancelCommand = true)]
        private async Task DoThingAsync(int? time, CancellationToken token = default)
        {
            try
            {
                await Task.Delay(time.GetValueOrDefault(), token);
            }
            catch (OperationCanceledException) { }
        }

        private bool CanRunDoThing(int? time) => true;

    }

The generated code looks like (the comments are mine):

        [global::System.CodeDom.Compiler.GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.0.0.0")]
        [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        public int Counter
        {
            get => counter;
            set
            {
                if (!global::System.Collections.Generic.EqualityComparer<int>.Default.Equals(counter, value))
                {
                    OnCounterChanging(value);
                    counter = value;
                    OnCounterChanged(value);
                    // this call runs fine
                    OnPropertyChanged(global::CommunityToolkit.Mvvm.ComponentModel.__Internals.__KnownINotifyPropertyChangedArgs.Counter); 
                    // !! exception occurs here !!
                    DoThingCommand.NotifyCanExecuteChanged();
                }
            }
        }

I'm guessing this is occurring because the Timer callback goes on the thread pool but the Command CanExecuteChanged event needs to be raised from its original thread? But I expect I should be able to change the Counter property from any thread, right?

The ObservableProperty attribute does not cause similar exceptions (so far as I've seen) for its OnPropertyChanged event.

Thank you very much for any thoughts/help.

[Sergio0694]

Raising the event itself doesn't care about the thread, what matters is if there's anything on the UI that's subscribed to that event and doing something. I'd assume that is crashing for you because you have a button or something bound to that command, but not the the other property. If you tried to also bind something to that property, you should see the same crash as well. Either way this is not an issue with the MVVM Toolkit itself 🙂

[avsteele]

Thanks again Sergio.

TextBlock is actually bound to the property and that doesn't have any issue. A button binds to the Command and the property as well as a CommandParameter.

<Window x:Class="Community8Test.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Community8Test"
        mc:Ignorable="d"
        Title="MainWindow"
        SizeToContent="WidthAndHeight"
        d:DataContext="{d:DesignInstance local:MainWindowVM}"
        >
    <Window.Resources>
        <Style TargetType="TextBlock">
            <Setter Property="FontSize" Value="24"/>
        </Style>
    </Window.Resources>
    <StackPanel>
        <TextBlock Text="{Binding Counter}"/>
        <Button Content="DoAsync" Command="{Binding DoThingCommand}" CommandParameter="{Binding Counter}"/>
        <Button Content="Cancel" Command="{Binding DoThingCancelCommand}"/>
    </StackPanel>
</Window>

I confirm though that changing the Property via the Dispatcher avoids the error.

        private void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
        {
            // no error
            App.Current.Dispatcher.Invoke(() => { Counter = (Counter + 200) % 3000; });
            // error
            //Counter = (Counter + 200)%3000;
        }

Feel like I'm still missing something though.

[avsteele]

Hi Sergio (or anyone) I am back to trying to use the ToolKit and would like to ask another question on this same topic.

If i have a property on a ViewModel implementing INotifyPropertyChanged, it does not matter which thread changes the property, as changes to it never raise exceptions relating to ownership. This is true even if a UI element is bound to the property (as in the TextBlock above)

However, If I have a command which updates its CanExcute status based on the value of that property, I will get exceptions unless all changes to that property occur on the dispatcher.

It really seems like the commands behave differently in this regard form property changes. Is this really the intended behavior? Why aren't the command state changes sent to the dispatcher behind the scenes like the property change notifications?

Thank you for any feedback/guidance.

[RobTF]

I'm seeing this too, but in my case I think it's an issue with .NET MAUI as rightly, the MVVM library shouldn't care about threading. The UI framework however, should deal with such bindings safely.