Can Source Generators Further Simplify Synchronization in MVVM Community Toolkit

[giiyms]

Overview

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.

API breakdown

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.

Usage example

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

---

Breaking change?

No

Alternatives

None

Additional context

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.

Help us help you

No, just wanted to propose this