CS8080 forces pointless override of property accessors

[paulomorgado]

class Parent
{
    public virtual bool Property { get; set; }
}

class Child : Parent
{
    public override bool Property { get; } // CS8080 Auto-implemented properties must override all accessors of the overridden property.
}

Besides the uselessness of the that override, why is this not allowed?

This is allowed:

class Child : Parent
{
    private readonly bool field;
    public override bool Property { get => field; }
}

(https://stackoverflow.com/questions/50377162/why-can-a-full-property-in-c-sharp-be-overridden-with-only-a-getter-but-it-can-s?noredirect=1#comment87814307_50377162)

[Logerfo]

Why isn't the virtual keyword allowed in accessors? Like that:

public bool Property { virtual get; set; }

Has this already been discussed?

[HaloFour]

@Logerfo

Why isn't the virtual keyword allowed in accessors?

What would be the syntax for a derived type extending that accessor? As the property itself is not virtual you couldn't use the syntax expected today.

To IL the properties themselves aren't virtual/sealed, only their accessors are. It doesn't care if one of the accessors is sealed and the other is virtual. But when you override a property the C# compiler also creates another property entry in the derived type, which is where additional metadata goes such as attributes. While you can define that entry with accessors from a base type, the verifier reports the following error:

[MD]: Error: Property has related method belonging to another type

So, it might be possible to come up with a syntax to override a specific accessor from a base class, but it couldn't smell like a property override because the compiler can't emit additional property metadata.

[bondsbw]

This would produce unintended behavior as the backing field is regenerated for Child. A get operation would call Child.getProperty() while set would call Parent.setProperty(value) and write to the other backing field:

var c = new Child();
c.Property = true;
Console.WriteLine(c.Property); // "False"

[Joe4evr]

I'd be interested if the opposite could become allowed, at least when overriding an abstract property.

public abstract class Parent
{
    public abstract bool Property { get; }
}

class Child : Parent
{
    public override bool Property { get; internal set; } //currently reports CS0546 'Child.Property.set': cannot override because 'Parent.Property' does not have an overridable set accessor.
}

The current alternative is to write an explicit backing field + separate SetProperty method (per property you want to do this with), which I feel is more Noise than Signal, to be honest.

Potential alternative syntax options:

• public bool Property { override get; internal set; }
• public override bool Property { get; new internal set; }

[MrJul]

@Joe4evr I've written a proposal a long time ago on the Roslyn repository about that. I've now submitted it to this repo: see #1568.