Observable auto properties

[shawnshaddock]

This is a proposal to add an observable keyword to auto properties. This keyword would be a shorthand way for implementing property change notification.

public observable string FirstName { get; set; }

The exact details of how it would implement the property change notification aren't completely hashed out, but this is one idea (FirstNameChanged event + OnFirstNameChanged method)

private string _FirstName;
public string FirstName
{
    get => _FirstName;
    set
    {
        _FirstName = value;
        OnFirstNameChanged();
    }
}

public event EventHandler FirstNameChanged;

protected virtual void OnFirstNameChanged()
{
    FirstNameChanged?.Invoke(this, EventArgs.Empty);
}

Another obvious way is implementing INotifyPropertyChanged, but that would be very invasive to the type. Possibly an implicit pattern could be used instead.

private string _FirstName;
public string FirstName
{
    get => _FirstName;
    set
    {
        _FirstName = value;
        OnPropertyChanged(nameof(FirstName));
    }
}

public event PropertyChangedEventHandler PropertyChanged;

protected virtual void OnPropertyChanged(string propertyName)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}

[Joe4evr]

Have you checked out Source Generators yet?

[jnm2]

Related: #1074

Also, #133 and #140 are being investigated for C# 10. With #133, your boilerplate would look like this:

public string FirstName
{
    string field;
    get => field;
    set
    {
        field = value;
        OnPropertyChanged(nameof(FirstName));
    }
}

And if you have a protected Set<T>(ref T field, T value, [CallerMemberName] string propertyName = null!) method like I do, it's:

public string FirstName { string field; get => field; set => Set(ref field, value); }

With #140, this would shrink even further:

public string FirstName { get; set => Set(ref field, value); }

[shawnshaddock]

The notify keyword proposal in #1074 is nice, it satisfies the same desire my proposal has, a very terse way to implement property changed notification.

public string FirstName { get; notify set; }

However I would prefer that this syntactic sugar generate a FirstNameChanged event and OnFirstNameChanged method, instead of the generic PropertyChanged event and OnPropertyChanged method.

I find the property specific events and methods to be more along the lines of what auto properties do (generate property specific code), it's more specific to the individual property and doesn't require an explicit interface (INotifyPropertyChanged). It's also easier for an observer to react to a specific property change (no need to switch on propertyName). This pattern is also already supported in areas of .NET (WPF, WinForms), and I haven't tested them, but probably ASP.NET and UWP as well.

[huoyaoyuan]

The key reason preventing this should be that .NET runtime doesn't have a standard way for change notification. There are ways in app models, so the sugar should be at app model level (generators), not fundamental level.