Post-initialization code for classes, records and structs

[K1vs]

The new language features associated with primary constructors are extremely attractive. In addition, the old capabilities of initializers are in great demand, especially after adding init; and required. But for me and my team personally, their use is often limited by the lack of ability to ensure the validity of a class instance.

It would be great to have a post-initialization option, something like:

public class Foo(int bar1, int bar2)
{
  postinit 
  {
    if(bar1< bar2)
    {
      throw new ArgumentException("Invalid bars");
    }
  }
}

or for initializer

public class Foo
{
  public required int Bar1 { get; init: }
  public required int Bar2 { get; init: }
  postinit 
  {
    if(Bar1  < Bar2 )
    {
      throw new ArgumentException("Invalid bars");
    }
  }
}

Now there are ways to get around this using a instance method like public void Initialize(), but there is a need to call it manually, and make sure that it is called exactly-once. Which is not always reliable enough, obvious and convenient.

Most likely, changes will be needed here not only in the language but also in the .net, although I could be wrong. But this was done during implementation required modifier, and this feature is ideologically related to it.

[ufcpp]

https://github.com/dotnet/csharplang/blob/main/meetings/2020/LDM-2020-05-04.md#final-initializers

[TahirAhmadov]

#6591

[K1vs]

Is there any update on this topic? The above links are without news. And this functionality would be very useful, since now the use of primary constructors, positional records, and the "with" operator is limited to situations where validation is not needed. And validation is needed very often, and even where it is not needed, teams are in no hurry to use new language features, since validation may be required later and they do not want to multiply approaches of class/record building.

[CyrusNajmabadi]

There is no update. We will update any discussion or issue when there is new information to share

[UniqeId6542]

I also think that this would be useful.
I'm not sure that the 'final-initializers' link from ufcpp is the same thing. I'm imagining a method (defined either by an interface or keyword) that is called after all of the properties have been set.
kind of like:

var f = new Foo
{
    Bar1 = 1,
    Bar2 = 2,
}; // post-init method called here.  (whether or not the {} were used)

I think that this would be useful in general classes too. Virtual methods shouldn't be called in a constructor. But since this is a method call after construction, the programmer can do any extra setup with virtual method calls here.

[jnm2]

I think you're describing the behavior of final initializers.

[dlebansais]

I solved this problem by using a simple public void Initialize() { ... } method (as suggested), and wrote an analyzer that ensures the method is called right after new().
It did not occur to me to check the method is called exactly once, but this is easily fixed with some IsInitialized field.
On the upside, it works with async methods and you can call virtual methods within initialization too.

[LFL-1031]

Foo foo = new Foo(){ Bar1 = 1, Bar2 = 2 }; // auto invoke init checked operator after initialize, throw an ArgumentException

public static void operator checked init(Foo foo)
{
    if(foo.Bar1 < foo.Bar2) { throw new ArgumentException("Invalid bars"); }
}