Remove the need for parenthesis on a parameterless primary constructor.

[tacosontitan]

Currently, to leverage primary constructors, parenthesis are required for the defining object, regardless of whether parameters are defined or not. Take the following simple example:

public abstract class Component(string name, string description)
{
    public string Name { get; set; } = name;
    public string Description { get; set; } = description;
}

public sealed FooComponent
    : Component(
        name: nameof(FooComponent),
        description: "A sample component for...")
{
    ...
}

This results in a compiler error:

Class 'FooComponent' must declare primary constructor (in the same type part) in order to use base type constructor call syntax.

Adjusting to satisfy results in:

public sealed FooComponent()
    : Component(
        name: nameof(FooComponent),
        description: "A sample component for...")
{
    ...
}

I understand it's only two characters, but why is it needed if we can already determine that the base type constructor call syntax is being used?

Clarification

My question is more geared towards the idea that the parentheses are required to use base-type constructor call syntax. Is it commonly known (or are there public discussions on) why that requirement is imposed?

[HaloFour]

but why is it needed if we can already determine that the base type constructor call syntax is being used?

Because you are still defining a primary constructor, albeit one that is parameterless.

public abstract class Component(string name, string description)
{
    public string Name { get; set; } = name;
    public string Description { get; set; } = description;
}

// with primary constructor
public sealed class FooComponent() : Component(
        name: nameof(FooComponent),
        description: "A sample component for...")
{
}

// without primary constructor
public sealed class BarComponent : Component
{
    public BarComponent() : base(
        name: nameof(FooComponent),
        description: "A sample component for...") { }
}

[CyrusNajmabadi]

@HaloFour i think the argument is: given a base-type-syntax which clearly indicates this is a primary constructor scenario, allow me to eschew the () on the class itself since it can be inferred.

I think the request is technically correct, but it's just one of those cases of: saving two chars here jsut doesn't seem that worthwhile.

[HaloFour]

Maybe, in the sense that you could also claim that a class that has no constructor has an implied parameterless primary constructor:

public class Foo : Object { }
// equiv to
public class Foo() : Object() { }

[tacosontitan]

I guess my question is more geared towards the idea that the parentheses are required to use base-type constructor call syntax. Is it commonly known (or are there public discussions on) why that requirement is imposed?

[HaloFour]

Probably because it wasn't considered that an empty parameterless constructor could be inferred to behave like a primary constructor. It's likely less an intentionally imposed limitation than the a feature of primary constructors that requires primary constructors. The question would be whether or not it's worth revisiting at this point to avoid two characters. Probably not, unless there are other reasons to revisit constructors in which case it could get bundled in if the language team considered it worthwhile.

[colejohnson66]

Why are records given special treatment with parameter-less constructors?

public record FooRecord;

[HaloFour]

Why are records given special treatment with parameter-less constructors?

Records have never required primary constructors. A record without a primary constructor just has the normal inferred parameterless constructor that any type would have.

However, if that record is extending from another record with a required constructor, and you want to use the base-type constructor syntax, you've always been required to have a primary constructor on the record, even if it is parameterless.

[tacosontitan]

FWIW @colejohnson66, that syntax is valid for record, interface, class, and struct:

public record Foo;
public interface IFizz;
public class Buzz;
public struct FizzBuzz;

[colejohnson66]

Ah. I had a brain fart; They’re required if you’re invoking a base constructor with parameters. Given that, I see your point more. If I’m invoking a base constructor, the lack of parenthesis on the type isn’t ambiguous and shouldn’t be needed.