Primary constructors in their current state are horrible

[jonashendrickx]

We should be able to make parameters of primary constructors protected, private or readonly. And possibly also enforce a consistent syntax, i.e. _camelCase for private fields, PascalCase for protected/public fields.

public class TellTale(private readonly string Id, readonly string Title);

public class ServiceA(private readonly IDependencyA, private readonly IDependencyB);

This would also address the inconsistency with classes where parameters of primary constructors are by default private and mutable, while with records they are public but immutable.

[yaakov-h]

And possibly also enforce a consistent syntax, i.e. _camelCase for private fields, PascalCase for protected/public fields.

The language does not guarantee that there will be any fields.

[chrisoverzero]

We should be able to make parameters of primary constructors protected, private or readonly.

What would it mean for a parameter to be protected?

And possibly also enforce a consistent syntax, i.e. _camelCase for private fields, PascalCase for protected/public fields.

You can assign the parameters from primary constructors to fields with whatever naming scheme you want, as enforceable by existing tools. The parameters themselves are not fields, they are parameters.

This would also address the inconsistency with classes […]

Non-record classes are different from record classes – record classes do more, by design. If they behaved the same, what would the point be of having both of them?

[tacosontitan]

I think you're confusing primary constructor parameters for fields. The parameters are not guaranteed to become fields, but if you want fields, then you can always explicitly map them like you would for any other constructor:

public class Sample(int foo)
{
    private readonly int _foo = foo;
    ...
}

This will ensure that you've mapped foo to a field and satisfies your requested accessibility constraints.

foo is a parameter and should be named and utilized as such. Constructors (primary or not) are just a special method for creating a new instance of your object, so even typical constructors have parameters that you can utilize directly and discard or map to fields:

public class Sample
{
    private readonly int _foo;
    private readonly IBarService _barService;
    public Sample(int foo, IServiceProvider serviceProvider)
    {
        _foo = foo;
        _barService = serviceProvider.GetRequiredService<IBarService>();
    }
}

In this example, serviceProvider does not become a field, nor would it when used the same way with a primary constructor:

public class Sample(int foo, IServiceProvider serviceProvider)
{
    private readonly int _foo = foo;
    private readonly IBarService _barService = serviceProvider.GetRequiredService<IBarService>();
}

As this SharpLab snippet demonstrates:

Primary constructors help us simplify our constructors and model definitions by giving us a way to extend the range available to their parameters.

[jonashendrickx]

I tested your suggestion. But with value types it can still to turn into a nightmare.

With reference types, you can still modify the parameter, and your readonly field will still update.

I like the implementation how it was done in Kotlin. But in .NET it can turn into an absolute nightmare.

[chrisoverzero]

I tested your suggestion.

Don't mix use of a parameter and a field which has had that parameter assigned to it. The compiler caught this for you – see the green smudge under the assignment to _wheels?

Parameter 'ushort wheels' is captured into the state of the enclosing type and its value is also used to initialize a field, property, or event.

That's the compiler's saying "probably don't do that". Pick one or the other.

[colejohnson66]

Perhaps a source generator+analyzer could be created. The generator would take all (or a subset of) parameters and store them into backing fields following the desired naming convention (paramA -> _paramA or m_paramA). The analyzer would warn (or error) on usages of the parameters (outside its own, obviously). So, the generator would do the following:

// your code
[PrimaryConstructorToFields(NamingConvention = PrimaryConstructorNamingConventions.UnderscorePrefix)]
public partial class MyClass(int value)
{
    public int GetValue =>
        value; // WARNING: Do not use primary constructor parameters; Use `_value` instead.
}

// generated
partial class MyClass
{
    private int _value = value;
}

It could even get fancy and skip making fields for ones you've already made, or even make the ones it adds readonly:

// your code
[PrimaryConstructorToFields(NamingConvention = PrimaryConstructorNamingConventions.MUnderscorePrefix)]
[PrimaryConstructorReadonlyFields(nameof(value))]
public partial class MyClass(string name, int value)
{
    private string _name = name ?? throw new ArgumentNullException(nameof(name));

    public string Name =>
        _name;
    public int Value =>
        m_value;
}

// generated
partial class MyClass
{
    private readonly int m_value = value;
}