Partial constructor extensions

[crener]

Currently we can do a lot with code generators where we define a full type using source generators. This means that a little metadata can create a fully realised structure. If we use this to create something like this:

[GeneratedCode("MyGenerator", "1.0.0")]
public partial class MyClass
{
    public int One { get; } 
    public string Two { get; }
    public double Three { get; }

    public MyClass(double param)
    {
        One = 1;
        Two = "2";
        Three = param;
    }
}

This is intended to be extended with bespoke functionality by a programmer like so:

public partial class MyClass
{
    public DateTime CurrentTime { get; }

    private MyClass()
    {
        CurrentTime = DateTime.Now;
    }
}

The generator can then detect this and modify the original code to call the constructor

public MyClass(double param)
	: this()
    {
        One = 1;
        Two = "2";

Once this happens we know that all the variables will be initialised but the compiler still generates warnings for CS8618 as the human authored constructor doesn't initialise the generated properties.

Proposal

Add an extra keyword to a method declaration that gives it the power to initialise getter only parameters but limits the method

• it can only be called from a constructor in the same type
• follows same restrictions as a constructor
  • Can't be virtual
  • Can't be async
  • Lambdas can't set variables local to the method

This means our generated code turns to this:

[GeneratedCode("MyGenerator", "1.0.1")]
public partial class MyClass
{
    public int One { get; } 
    public string Two { get; }
    public double Three { get; }

    public MyClass(double param)
    {
        One = 1;
        Two = "2";
        Three = param;
    }
	
    private partial KEYWORD void Init();
}

and the human authored class moves it's initialisation logic to Init:

public partial class MyClass
{
    public DateTime CurrentTime { get; }

    private partial KEYWORD void Init()
    {
        CurrentTime = DateTime.Now;
    }
}

Now the compiler can look at all constructors and check if they are calling any constructor extension that sets a property and know that all types will be initialised.

Personal candidates for the keyword that denotes this are explicit and scoped but others could be used instead.

Additional use cases

• Reusing functionality between constructors with different parameters
• Splitting constructor logic over multiple files

Similar proposals

#318 different as this is not applicable to properties
#348 applies to properties as well but this adds more modern use-cases
#4238 trying to solve the same core issue but proposed solutions do not work as this use-case is crossing the source gen to human authored boundary
#1871 fundamentally a good approach but lacks the source gen use-case

[jaredpar]

I think that init methods are the most likely path forward for this. Those would be methods callable from constructors or other init methods that have the ability to set readonly members. If that were available then you could use a partial init member that the source generator could fill out.

[crener]

Oh I didn't know that was a thing. That looks amazing.

There doesn't seem to be any movement on the ticket, do you know what happened or if this is planned for a future release?

[crener]

Oh it's been mentioned in C#11 in the context of required members so it still seems to be a plan but not been able to find any plans around init methods themselves.

https://github.com/dotnet/csharplang/blob/5214f6e9da9c05bb2c9276802893cb9549c5f694/proposals/csharp-11.0/required-members.md

Given C# 12 is released and C# 13 is about to come out and I've not seen this in the roadmap, maybe C# 14?

[jaredpar]

This feature falls into the bucket of we understand how it works and it fits into the general theme of other work that we've done. But it's lacked motivating scenarios thus far so hasn't moved to implementation.

It's come up a few times over the last month so I'll likely bring it up again to see LDM thinks the scenarios are there now.

[crener]

Well that sounds somewhat promising.

At least in my case everything that calls the above example is source generated and init methods sound like a perfect companion to customising code generated structures.

I wish you good luck.