Can Source Generators Further Simplify Synchronization in MVVM Community Toolkit?

[giiyms]

I’m using the MVVM Community Toolkit to keep a ViewModel synchronized with a Model, handling both properties and collections. The [ObservableProperty] attribute already simplifies INotifyPropertyChanged implementation, but bidirectional synchronization between the ViewModel and Model still requires manually writing event handlers and update logic. This becomes repetitive and prone to errors, especially with multiple properties or collections.

Current Code:
Here’s my current ViewModel implementation, which synchronizes a Name property and an Items collection with a Model:

using CommunityToolkit.Mvvm.ComponentModel;
using System.Collections.ObjectModel;
using System.Collections.Specialized;

public partial class ViewModel : ObservableObject
{
    private readonly Model model;
    private bool isSyncing = false;

    [ObservableProperty]
    private string name;

    [ObservableProperty]
    private ObservableCollection<string> items = new ObservableCollection<string>();

    public ViewModel(Model model)
    {
        this.model = model;

        // Initialize properties from the Model
        Name = model.Name;

        // Initialize the collection from the Model
        foreach (var item in model.Items)
        {
            Items.Add(item);
        }

        // Sync properties: Update ViewModel when Model changes
        model.PropertyChanged += (sender, e) =>
        {
            if (e.PropertyName == nameof(Model.Name))
            {
                Name = model.Name;
            }
        };

        // Sync collections: Update ViewModel.Items when Model.Items changes
        model.Items.CollectionChanged += (sender, e) =>
        {
            if (!isSyncing)
            {
                isSyncing = true;
                if (e.Action == NotifyCollectionChangedAction.Add)
                {
                    foreach (string item in e.NewItems)
                    {
                        Items.Add(item);
                    }
                }
                else if (e.Action == NotifyCollectionChangedAction.Remove)
                {
                    foreach (string item in e.OldItems)
                    {
                        Items.Remove(item);
                    }
                }
                isSyncing = false;
            }
        };

        // Sync collections: Update Model.Items when ViewModel.Items changes
        Items.CollectionChanged += (sender, e) =>
        {
            if (!isSyncing)
            {
                isSyncing = true;
                if (e.Action == NotifyCollectionChangedAction.Add)
                {
                    foreach (string item in e.NewItems)
                    {
                        model.Items.Add(item);
                    }
                }
                else if (e.Action == NotifyCollectionChangedAction.Remove)
                {
                    foreach (string item in e.OldItems)
                    {
                        model.Items.Remove(item);
                    }
                }
                isSyncing = false;
            }
        };
    }

    // Sync properties: Update Model when ViewModel's Name changes
    partial void OnNameChanged(string value)
    {
        model.Name = value;
    }
}

Issue:
While functional, this code involves a lot of boilerplate:

• Manual event subscriptions for PropertyChanged and CollectionChanged.
• Explicit initialization of properties and collections from the Model.
• Repeated logic to update one side when the other changes, including an isSyncing flag to avoid infinite loops.

Question:
Could the MVVM Community Toolkit leverage source generators to eliminate this boilerplate? I’d love to see a solution where synchronization is defined declaratively (e.g., via attributes), and the source generator handles all the event wiring and updates behind the scenes.

Hypothetical Example:
Here’s what I envision the code could look like with source generators:

using CommunityToolkit.Mvvm.ComponentModel;

[SyncWithModel(typeof(Model))]
public partial class ViewModel : ObservableObject
{
    private readonly Model model;

    public ViewModel(Model model)
    {
        this.model = model;
    }

    [SyncProperty("Name")]
    [ObservableProperty]
    private string name;

    [SyncCollection("Items")]
    [ObservableProperty]
    private ObservableCollection<string> items = new ObservableCollection<string>();
}

How It Could Work:

• [SyncWithModel(typeof(Model))] specifies that this ViewModel synchronizes with the Model class.
• [SyncProperty("Name")] marks the name property for bidirectional synchronization with Model.Name.
• [SyncCollection("Items")] marks the items collection for bidirectional synchronization with Model.Items.

The source generator could then:

• Initialize name and items from the Model in the constructor.
• Subscribe to PropertyChanged on the Model to update name.
• Subscribe to CollectionChanged on both Model.Items and ViewModel.Items for two-way updates.
• Generate the update logic with an isSyncing guard to prevent infinite loops.

Request:
Would the MVVM Community Toolkit team consider adding this kind of source-generator-based synchronization? It would make the code much cleaner and more maintainable. If this is doable, what challenges might arise in implementing it? Alternatively, if there’s an existing way to achieve this with less boilerplate, I’d appreciate pointers or examples.

[weitzhandler]

I rather the whole process of having to manually write all the model's properties is tedious and error prone.
I think the way forward is to have it all generated for you. See #1069.

[michael-hawker]

The way I see it, if your model is observable anyway (as seems OPs case above), just use it directly, why bother re-wrapping and doing all the forwarding? You can still keep logic out of those objects and have them manipulated by ViewModels and such, but still bind directly to them in a UI. At least that's how I see things usually, keeps things more streamlined. Keep the main separation between the View and the rest of your data, that's where the main benefits of MVVM come from.

Use wrappers and forwarding if you have data coming from external sources that are outside of your control, that's where I see @weitzhandler's proposal has value.

[weitzhandler]

I meant if you want reuse the DTO models (e.g. gRPC Protobuf generated etc.) which are not INPC and its collections are not observable, then wrappers would be beneficial.
Similar to how WCF entities used to be generated for Silverlight back in the day...