Proposal: Auto properties with custom setters

[silver-sd]

If the 'implicit' keyword is specified, the property declaration has only a single body, which is executed after the property's backing field has changed.

public implicit Type PropertyName
{
	f(PropertyName); //this code is executed after the property has changed
}

The compiler generates the following code for this syntax:

Type _propertyName;	//or some hidden name
public Type PropertyName
{
	get => _propertyName;
	set
	{
		if(_propertyName == value)	//auto generated
			return;
		_propertyName = value;		//auto generated
		
		f(PropertyName); //this code is executed after the property has changed
	}
}

---

If the 'explicit' keyword is specified, the field assignment must be made manually.

public explicit Type PropertyName
{
	//before change
	field = value;	//Required explicit assignment. "field" is the new keyword.
	//after change
}

The compiler generates this:

Type _propertyName;
public Type PropertyName
{
	get => _propertyName;
	set
	{
		if(_propertyName == value)	//auto generated
			return;
		
		//before change
		_propertyName = value;	//required explicit assignment
		//after change		
	}
}

---

If the getter and setter have different access modifiers, the modifier placed after the "implicit" keyword applies to the setter:
public implicit protected Type PropertyName {}

The compiler generates this:

public Type PropertyName
{
	get => _propertyName;
	protected set	//the modifier after 'implicit' keyword is used
	{
	...

---

There are two options that differ only by "field = value;", but both are necessary.
The 'implicit' option is expected to be used in most scenarios. It enhances code readability.
However, if actions are sometimes needed before the assignment "field = value;", having two options helps to avoid completely rewriting the code.

[HaloFour]

See: #140

[jnm2]

To elaborate, this is what you will be able to do using langversion=preview when C# 13 releases, and eventually langversion=14:

public Type PropertyName
{
    get;
    set
    {
        if (field == value) return;
        field = value;
	f(PropertyName);
    }
}

If you use a helper method, you could write it as:

public Type PropertyName { get; set => Set(ref field, value, onChanged: () => f(PropertyName)); }

[AndersKehlet]

Is there a list of current preview features anywhere? I think I've searched all the relevant repos, but I may just be blind.

[ufcpp]

https://github.com/dotnet/roslyn/blob/main/docs/Language%20Feature%20Status.md

[silver-sd]

It was intended for customizing properties by SourceGenerators (the simplest way to pass the property code for SG).

Currently available implementation:

[MyPropGenerator<Type>] void PropertyName(){ /*this code will be passed to SG*/ } 
[MyPropGenerator] void PropertyName(Type value){/*code for SG*/}

This would look better:

[MyPropGenerator] public Type PropertyName
{
	//code for SG, may contain: field=value;
}

This one doesn't look better than using functions:

[MyPropGenerator] public Type PropertyName
{get;set{
	//code for SG
}}

[jnm2]

To source-generate the property implementation, you can use the new C# 13 partial properties feature (https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-13#more-partial-members).

[MyPropGenerator]
public partial Type PropertyName { get; set; }

The source generator can then emit:

private Type propertyName;
public partial Type PropertyName 
{
    get => propertyName;
    set
    {
        if (propertyName == value) return;
        propertyName = value;
	// More source-generated code
    }
}

[333fred]

@jnm2 field is not available in C# 13.

[jnm2]

Thanks, fixed