[Proposal] [ComputedProperty] — auto-wired derived MVVM properties via source generation

[maxplex]

Add a [ComputedProperty] attribute (alongside [ObservableProperty]) to support read-only, computed properties that automatically raise PropertyChanged when any of their observable dependencies change — with zero manual wiring code

Motivation / Problem

Today, derived MVVM properties require tedious manual boilerplate:

// Current approach
[ObservableProperty] public partial string FirstName { get; set; }
[ObservableProperty] public partial string LastName { get; set; }

// Must repeat for every dependency, on every computed property
partial void OnFirstNameChanged(string? _) => OnPropertyChanged(nameof(FullName));
partial void OnLastNameChanged (string? _) => OnPropertyChanged(nameof(FullName));

public string FullName => $"{FirstName} {LastName}";

This scales poorly: N computed properties × M dependencies = N×M wiring methods, all hand-written and easy to miss when adding a new dependency.

Proposed API
namespace CommunityToolkit.Mvvm.ComponentModel;

/// <summary>
/// Marks a read-only property as a computed/derived property.
/// The source generator auto-detects its observable dependencies
/// and emits the necessary PropertyChanged forwarding.
/// </summary>
[AttributeUsage(AttributeTargets.Property)]
public sealed class ComputedPropertyAttribute : Attribute
{
    /// <summary>
    /// Optional explicit dependency list. When set, auto-detection is skipped.
    /// </summary>
    public string[]? DependsOn { get; set; }
}

Usage

public partial class PersonViewModel : ObservableObject
{
    [ObservableProperty] public partial string firstName { get; set; }
    [ObservableProperty] public partial string lastName  { get; set; }

    [ComputedProperty]                          // ← auto-detects FirstName + LastName
    public string FullName => $"{FirstName} {LastName}";

    [ComputedProperty]                          // ← auto-detects FullName
    public string Greeting => $"Hello, {FullName}!";

    // Explicit override for complex/indirect getters:
    [ComputedProperty(DependsOn = new[] { nameof(FirstName) })]
    public string Initials => $"{FirstName[0]}.";
}

[nas-rda]

This would be a great thing to have in the base library to further reduce boilerplate code.

I had to roll a similar solution in a project I am working on (minus auto-detection). The first iteration looked just like what you proposed but then it evolved to also "hook" into other INPC implementations with support for updating references:

[ComputedProperty(Source = nameof(RefreshCommand), DependsOn = [nameof(IAsyncRelayCommand.IsRunning)])
public string TitleText => $"Home page {(RefreshCommand.IsRunning ? "(loading...") : "")}";

The generated code looked roughly like:

void HookPropertyChangedWhenEvents()
{
	this.PropertyChanging += UnhookChildPropertyChangedOnPropertyChanging;
	this.PropertyChanged += HookChildPropertyChangedEventOnPropertyChanged;
	RefreshCommand?.PropertyChanged += __RefreshCommand_PropertyChanged;
}

void UnhookPropertyChangedWhenEvents()
{
	this.PropertyChanging -= UnhookChildPropertyChangedOnPropertyChanging;
	this.PropertyChanged -= HookChildPropertyChangedEventOnPropertyChanged;
	RefreshCommand?.PropertyChanged -= __RefreshCommand_PropertyChanged;
}

private void UnhookChildPropertyChangedOnPropertyChanging(object? sender, PropertyChangingEventArgs e)
{
	if (e.PropertyName == nameof(RefreshCommand))
	{
		RefreshCommand?.PropertyChanged -= __RefreshCommand_PropertyChanged;
	}
}

private void HookChildPropertyChangedEventOnPropertyChanged(object? sender, PropertyChangedEventArgs e)
{
	if (e.PropertyName == nameof(RefreshCommand))
	{
		RefreshCommand?.PropertyChanged += __RefreshCommand_PropertyChanged;
	}
}

private void __RefreshCommand_PropertyChanged(object? sender, PropertyChangedEventArgs e)
{
	if (e.PropertyName == nameof(RefreshCommand.IsRunning))
	{
		OnPropertyChanged(propertyName: nameof(TitleText));
	}
}

[RichardD2]

With the current library, surely the simplest approach is to add NotiftPropertyChangedFor on the observable properties:

[ObservableProperty] 
[NotifyPropertyChangedFor(nameof(FullName))]
public partial string FirstName { get; set; }

[ObservableProperty] 
[NotifyPropertyChangedFor(nameof(FullName))]
public partial string LastName  { get; set; }

public string FullName => $"{FirstName} {LastName}";

Notifying dependent properties - ObservableProperty attribute - Community Toolkits for .NET | Microsoft Learn

---

However, I do think it would be nice to have an attribute on the dependent property, even if you had to manually list the properties it depends on:

[ObservableProperty] 
public partial string FirstName { get; set; }

[ObservableProperty] 
public partial string LastName  { get; set; }

[DependsOn(nameof(FirstName))]
[DependsOn(nameof(LastName))]
public string FullName => $"{FirstName} {LastName}";

[tschbc]

@RichardD2 Would [NotifyPropertyChangedFor(nameof(FullName))] treat FullName as an observable property? I'm assuming yes, but my inexperience is showing :)