[Proposal] Multiple primary constructors.

[ichensky]

Currently, in C#, classes can have only one primary constructor.
However, it could be useful to have multiple primary constructors.

• To separate all constructors from methods and data.
• If one constructor is already defined as primary and another is needed, with multiple primary constructors there's no need to refactor the code or change the history(in git/svn) of already tested code, except adding one new line.

Example of syntax/variant 1:

class Foo
    (int x, int y) : BaseFoo(a, b), 
    (Point point) : BaseFoo(point)     
    { 
        // methods ...
    }

Behave like just multiple regular constructors without ctor-method body.
Equals to code:

class Foo : BaseFoo
{
    public Foo(Point point) : base(point) { }
    
    public Foo(int x, int y) : base(x, y) { } 
}

Example of syntax/variant 2:

class Foo
    (int x, int y) : BaseFoo(a, b) | (Point point) : BaseFoo(point)     
    { 
        // methods ...
    }

Variables from both constructors and united and have default values.
Equals to code:

class Foo : BaseFoo
{
    int x, y;
    Point point;

    public Foo(int x, int y){
       x = x;
       y = y;
       base(x, y);
   }
   
    public Foo(Point point){
       point = point;
       base(point);
   }
}

[333fred]

What advantage does having multiple primary constructors bring over having 2 regular constructors? You can already separate constructors from methods easily enough by just maintaining order in your definitions. The likelihood that adding a new primary constructor would not change the existing code is extremely low, as it would invalidate any constructor parameter captures in the rest of the body.

In general, the concept of "multiple primary" is somewhat conflicting.

[ichensky]

What advantage does having multiple primary constructors bring over having 2 regular constructors?

The answer should be the same as for the question:
What advantage does having primary constructor bring over having 1 regular constructor?

[333fred]

What advantage does having primary constructor bring over having 1 regular constructor?

Not needing to define fields for various capture elements is the main advantage I take out of them. This would break that.

[HaloFour]

The scoping doesn't make sense. How can you have a point value in scope for the entirety of the class if that is not the constructor that was called.

You can already declare secondary constructors which call the primary constructor, that is the correct way to do this:

class Foo(int x, int y) {
    Foo(Point pt) : this(pt.X, pt.Y) { }

    // x and y are in scope here, pt is not
}

[ichensky]

Thanks for clarification, in this case can be two variants.
a. Variables from both constructors can have default values. Which is fine in many cases where not every byte of memory is calculated.

class Foo : BaseFoo
{
    int x, y;
    Point point;

    public Foo(int x, int y){
        x = x;
        y = y;
       base(x, y);
   }
   
    public Foo(Point point){
        point = point;
       base(point);
   }
}

b. Multiple primary constructors will behave like just multiple regular constructors without ctor-method body.
(This variant is more preferable for me.)

class Foo : BaseFoo
{
    public Foo(Point point) : base(point) { }
    
    public Foo(int x, int y) : base(x, y) { } 
}

[HaloFour]

Multiple primary constructors will behave like just multiple regular constructors without ctor-method body.

You can already write normal constructors. Primary constructors aren't just shorthand for writing normal constructors, their entire point is that the constructor parameters are definitely assigned and in scope for the entire type.

[CyrusNajmabadi]

class Foo
    (int x, int y) : BaseFoo(a, b), 
    (Point point) : BaseFoo(point)     
    { 
        // methods ...
    }

I don't understand the semantics here. How would methods know if they could access x, y, or point? Some 'Foos' would be instantiated with an x and y and no point, and vice versa. No methods would be safe to write.

[ichensky]

Thanks for pointing that out. Updated description with code examples.

[HaloFour]

Why are you trying to use primary constructors here? They are not intended to be shorthand for regular constructors, their entire point is in capturing the parameter values across the scope of the entire type. Attempting to splat all constructors parameters as captures would subvert that and lead to an awful developer experience. This proposal solves no problems but creates some really bad ones.