WPF: MVVM pattern and toolkit

public abstract class ObservableObject : INotifyPropertyChanged, INotifyPropertyChanging

public sealed class MainViewModel : ObservableObject
{
    private string? _title;

    public string? Title
    {
        get => _title;
        set => SetProperty(ref _title, value);
    }

    private TaskNotifier? myTask;

    public Task? MyTask
    {
        get => myTask;
        set => SetPropertyAndNotifyOnCompletion(ref myTask, value);
    }
}

<StackPanel>
    <Label Content="{Binding MyTask.Status}" />
    <TextBox Text="{Binding Title}" />
</StackPanel>

public abstract class ObservableRecipient : ObservableObject

public sealed class MainViewModel : ObservableRecipient, IRecipient<RequestMessage<int>>
{
    public void Receive(RequestMessage<int> message) => throw new NotImplementedException();
}

public sealed class MainViewModel : ObservableRecipient
{
    // For best results and to avoid memory leaks, it's recommended to use OnActivated to register
    // to messages, and to use OnDeactivated to do cleanup operations.
    protected override void OnActivated()
        => Messenger.Register<MainViewModel, RequestMessage<int>>(this, (r, m) => r.Receive(m));

    // By default, OnDeactivated automatically unregisters the current instance from all registered messages.
    protected override void OnDeactivated() => base.OnDeactivated();

    public void Receive(RequestMessage<int> message) => throw new NotImplementedException();
}

public abstract class ObservableValidator : ObservableObject, INotifyDataErrorInfo

[ObservableProperty]
[NotifyPropertyChangedFor(nameof(FullName))] // Notifying dependent properties
[NotifyCanExecuteChangedFor(nameof(MyCommand))] // Notifying dependent commands
[NotifyDataErrorInfo] // Requesting property validation
[Required]
[MinLength(2)] // Any other validation attributes too...
[NotifyPropertyChangedRecipients] // Sending notification messages [PropertyChangedMessage<T>]
[property: JsonPropertyName("name")] // Adding custom attributes
private string? _name;

// only use in cases where the target types cannot just inherit from the equivalent
// types (eg. from ObservableObject).
[INotifyPropertyChanged]
public partial class MyViewModel : SomeOtherType

dotnet add package Microsoft.Extensions.DependencyInjection # --version 8.0.0

public partial class App : Application
{
    public IServiceProvider Services { get; set; }

    public App()
    {
        Services = ConfigureServices();
    }

    protected override void OnStartup(StartupEventArgs e)
    {
        var mainWindow = Services.GetRequiredService<MainWindow>();
        mainWindow.Show();
    }

    private ServiceProvider ConfigureServices()
    {
        var services = new ServiceCollection();

        services.AddTransient<MainWindow>();
        services.AddTransient<MainViewModel>();

        return services.BuildServiceProvider();
    }
}

public sealed class MainViewModel : ObservableObject
{
    public IRelayCommand OKCommand { get; } = new RelayCommand(() => { }, () => true);

    public IAsyncRelayCommand CancelCommand { get; } = new AsyncRelayCommand(() => Task.CompletedTask);
}

[RelayCommand(CanExecute = nameof(CanGreetUser))]
private void GreetUser(User? user)
{
    Console.WriteLine($"Hello {user!.Name}!");
}

private bool CanGreetUser(User? user)
{
    return user is not null;
}

[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(GreetUserCommand))]
private User? selectedUser;

// Call IAsyncRelayCommand.Cancel to signal that token.
[RelayCommand(IncludeCancelCommand = true)]
private async Task DoWorkAsync(CancellationToken token)
{
    // Do some long running work...
}