Has anyone tried .NET CommunityToolkit MVVM and Avalonia?

[tyHdev]

Has anyone tried implementing .NET Community Toolkit MVVM for their AvaloniaUI project? If so, how seamless was this process and how would you compare this approach to ReactiveUI or other MVVM frameworks?

[wieslawsoltes]

I used it for several projects, no issues so far.

[timunie]

I use it side by side with Reactive UI. I love the source generators most. For me it works without any issue.

[maxkatz6]

As others have mentioned, it should just work.
Only one possible issue that you might have - conflict between attribute validation of Avalonia and the Toolkit - #8397. Basically both libraries generate the validation errors resulting in duplicates. Can be easily solved though.

[liugangnhm]

how i can use route with CommunityToolkit MVVM?

[jack775544]

Nothing special is needed to use it. Just follow the CommunityToolkit MVVM docs and you should have no issues.

[hahyes]

I prefer CT MVVM over ReactiveUI and so far I had no problems with it.

[timahrentlov]

Using RC1, I have a couple of places where WhenAnyValue and ObservableForProperty simply won't work. But when I replace it with an alternative implementation, it works again. Mind you, it is only in some viewmodels it does not work.

Example, I have a Status field defined like this:

[ObservableProperty] private string _status = string.Empty;

and this code to listen for changes:

  this.WhenAnyValue(p => p.Status)
            .Subscribe(s =>
            { 
                Debug.WriteLine($"WhenAnyValue: Status is set to {s}");            
            }).DisposeWith(disposables);

then I only get the initial value.

If I then just below insert this code:

 this.WhenPropertyChanged(vm => vm.Status)
            .Subscribe(s =>
            { 
                Debug.WriteLine($"WhenPropertyChanged: Status is set to {s}");            
            }).DisposeWith(disposables);

then I get the updates written to console.

I don't know why, but something is not right, but I'm a bit scared of the bundled ReactiveUI extension right now, and would appreciate to be told what I'm doing wrong and that I'm an idiot.

FYI, the WhenPropertyChanged is a plain INotifyPropertyChanged vanilla implementation:

public static IObservable<TProperty> WhenPropertyChanged<T, TProperty>(this T self, Expression<Func<T, TProperty>> property) where T : INotifyPropertyChanged
   {
   	return Observable.Create<TProperty>(o =>
   	{
   		if (property.Body is not MemberExpression body)
   		{
   			throw new ArgumentException("'propertyExpression' should be a member expression");
   		}

   		var memberInfo = body.Member;
   		var propertyInfo = memberInfo as PropertyInfo;
   		var propertyName = propertyInfo?.Name ?? "Unknown property";
   		var propertySelector = property.Compile();

   		return self.WhenPropertyChanged(propertyName)
   			.Select(e => propertySelector(self))
   			.StartWith(propertySelector(self))
   			.DistinctUntilChanged()
   			.Subscribe(o);
   	});
   }

private static IObservable<PropertyChangedEventArgs> WhenPropertyChanged(this INotifyPropertyChanged self, string propertyName)
   {
       return self.WhenPropertyChanged().Where(e => e.PropertyName == propertyName);
   }

[timunie]

WhenAnyValue requires the class to raise PropertyChanged-event for the property to observe. If that is given, it worked for me (also with the CT-MVVM package).

[timahrentlov]

@jack775544

I think you're correct

In the VM where WhenAnyValue works, it inherits directly from ObservableObject.

In the VM where WhenAnyValue does not work, it inherits from RoutableViewModelBase : ObservableObject, IRoutableViewModel, IActivatableViewModel, where IRoutableViewModel looks like: IRoutableViewModel : IReactiveObject.

When trying to dive into how WhenAnyValue is implemented I can't seem to finde where it works with INotifyPropertyChanged.

[timunie]

The solution seems to be easy. Just a single line missed:

public partial class MainViewModel : ObservableObject
{
    [ObservableProperty] string? _Greeting;

    public MainViewModel()
    {
        this.WhenAnyValue(vm => vm.Greeting)
            .ObserveOn(RxApp.MainThreadScheduler) // This line is important! 
            .Subscribe(s => Debug.WriteLine($"New value is: {s}"));
    }
}

[timahrentlov]

@timunie

Yes, I'm using that in "real code" where needed :)
When I apply it here it does not make a difference.
Also, my own plain vanilla implementations works without. (So does DynamicData, see below)

I think the reason it works for you, in your example, is because you inherit directly from ObservableObject. In those situations, ReactiveUI's implementation of WhenAnyValue works for me as well.

For now, I'm gonna shun ReactiveUI's implementations like the plague, and roll with DynamicData.Binding.NotifyPropertyChangedEx versions of:

WhenPropertyChanged
WhenAnyPropertyChanged
WhenChanged
WhenValueChanged

Those works regardless of potential inheritance issues and I rely heavily on SourceCache in my project anyway.

Thanks!

[textGamex]

@timahrentlov I'm sorry to bother you after such a long time, but I've encountered the same issue in my project. Is there any solution available now?