[Proposal]: Implicit primary constructors

[McChoc]

Summary

This proposal aims to improve the readability and flexibility of primary constructors by moving their parameters from the class declaration to the class body. The contextual keywords param, params and base would be allowed in front of fields, properties, and events to initialize them from an implicit primary constructor.

Motivation

C# 12 introduced primary constructors, which help reduce boilerplate constructor code. However, they have two major drawbacks:

1. They have limited flexibility
   The parameters of primary constructors are stored as mutable private fields. They cannot be public, they cannot be properties or events and, most importantly, they cannot be readonly.

2. They clutter the class declaration
   If a class has multiple primary constructor parameters that are passed to the base constructor, the class declaration can become hard to read. Formating all these parameters and arguments is not intuitive. The issue is even worse if the class implements a number of interfaces and has generic type constraints.

This proposal addresses both issues by moving constructor parameters from the class declaration to the class body while maintaining the benefits of primary constructors.

Syntax

Current C# 12 Primary Constructor Syntax

public class Spaceship(string name, int crewSize)
{
}

Proposed Implicit Primary Constructor Syntax

public class Spaceship
{
    private param string _name;
    private param int _crewSize;
}

The param contextual keyword declares an implicit constructor where each marked member acts as both a parameter and a field/property/event. This approach eliminates clutter from the class declaration and, since the parameters are now members, they can have any access modifier, be readonly, or even be properties or events. The order of the param members in the class body determines the order of the constructor parameters.

public class Spaceship
{
    private readonly param string _name; // parameter assigned to a readonly field
    public param int CrewSize { get; set; } // parameter assigned to a public property
    public param event Action Load; // delegate parameter assigned to an event
}

// Constructor calls
var spaceship1 = new Spaceship("foo", 2, null);
var spaceship2 = new Spaceship(Load: null, CrewSize: 2, _name: "foo");

Implicit primary constructors would be an alternative to standard primary constructors, behaving similarly. Implicit primary constructors would always be public and if one is defined, all other constructors must call it using a this() constructor invocation.

public class Spaceship
{
    private param string _name;
    private param int _crewSize;

    public Spaceship() : this("", 1) { }
}

params modifier

The params modifier would allow a param member to accept a variable number of arguments. The params modifier would replace param, as having both would be redundant. Only one params member is allowed per class and no param members should be declared after the params member.

public class Fleet
{
    private params Spaceship[] _spaceships;
}

ref fields

Since a by-reference variable cannot be initialized with a value, if the param modifier is applied to a ref field, the implicit parameter would have to be ref as well. So, a param ref field would mean that both the implicit parameter and the field would have the ref modifier applied to them.

public ref struct Example
{
    private param ref int _number;
}

Equivalent to:

public ref struct Example
{
    private ref int _number;

    public Example(ref int number)
    {
        _number = ref number;
    }
}

Base constructors

If a class using an implicit primary constructor needs to pass arguments to a base constructor, the base keyword can be placed in front of the param or params modifier to specify that this parameter must be forwarded to the base constructor.

public abstract class Vessel
{
    protected Vessel(string registryNumber) { }
}

public class Spaceship : Vessel
{
    private base param string _registryNumber; // Passed to base constructor
    private param string _name;
    private param int _crewSize;
}

The order of the base param members must match the order of the parameters of the base constructor. If there are multiple base constructors the order and types of the base param members is what will determine which constructor is called.

public class Spaceship
{
    protected Spaceship(string name, int crewSize)
    {
        System.Console.WriteLine("A");
    }

    protected Spaceship(int crewSize, string name)
    {
        System.Console.WriteLine("B");
    }
}

public class SpaceshipA : Spaceship // Writes A
{
    private base param string _name;
    private base param int _crewSize;
}

public class SpaceshipB : Spaceship // Writes B
{
    private base param int _crewSize;
    private base param string _name;
}

Using this syntax should still enforce the standard execution order. This means that the base constructor should be called with the values passed to base param members before any value is assigned to any member.

Default values

Giving a param member an initial value by using the assignment operator would be useless since they will be assigned a value by the implicit constructor anyway. However, the syntax could still be used to define optional parameters for the implicit primary constructor. Optional param members must come after all required param members, but before the params member if any. params members cannot have default values.

public class Spaceship
{
    private param string _name;
    private param int _crewSize = 1;
}

// Constructor calls  
var spaceship1 = new Spaceship("foo", 2);
var spaceship2 = new Spaceship("foo");

Attributes

To add an attribute on an implicit primary constructor, you would use the method target.

[method: ValidatedContract]
public class Spaceship
{
    private param string _name;
    private param int _crewSize;
}

To add an attribute on the implicit parameter of a param member, you would use the param target.

public class Spaceship
{
    [param: ValidatedContract]
    private param string _name;
    private param int _crewSize;
}

Limitations

• It should not be possible to use both a C# 12 primary constructor and an implicit primary constructor in the same class. A class may have at most only one primary constructor.
• This syntax relies heavilly on the order of the members in the class body. This order is what defines both the signature of the implicit constructor and the overload of the base constructor that is invoked. This can be problematic, especially with partial classes. Having param members separated in multiple class bodies would make this order ambiguous. Therefore, only a single partial class body may have param members.
• A member should not be both param and required. Only one initilization method should be chosen.
• For properties and events, the param modifier would only be allowed if they are auto-implemented.
• Although param members act as parameters, the in and out modifiers would not be allowed on them.

Conclusion

This proposal improves primary constructors by providing more flexibility regarding how the parameters are implemented. It allows them to be implemented as either fields, properties or events. It allows them to be readonly or not. And it allows them to have any accessibility modifier. The proposal also improves readability by moving the parameters of primary constructors from the class definition to the class body.

[HaloFour]

I'm pretty sure a variant of syntax like this was proposed when primary constructors were first being designed.

IMO, they're not clearer. They hide a critical aspect of the contract within the class body which would be very easy to miss. An innocuous refactor such as reordering members would also incur breaking changes as it would impact the order of parameters to the constructor, not to mention the problem if said members are split between multiple partial definitions.