Constructor Properties

[mharthoorn]

Allow defining a primary constructor for a class or struct by using a keyword for each parameter
This removes boilerplate code but keeps immutability on public fields. This proposal overlaps with the discussions on record types and a previous proposal for primary constructors.

The following syntax

  public class Point
  {
    public in int X { get; }
    public in int Y { get; }
  }

becomes shorthand for

  public class Point
  {
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
      this.X = x;
      this.Y = y;
    }
  }

Of course different and possibly better keywords can be found, since it should probably be a contextual keyword, for example:

  public input int X { get; } 

  public primary int X { get; } 

  public constructor int X { get; } 

[HaloFour]

How would this work with partial types?

[DavidArno]

How would this idea offer any benefit over records?

public class Point(int X, int Y);

[mharthoorn]

@DavidArno: it has overlap. but the use case is different. The primary use case here would be larger / more complex applications that usually have have some form of dependency injection and a large constructor parameter list. Records seem to be focused at simpler types and immutability.

[HaloFour]

The concept of constructor-based dependency injection and primary constructors would be mutually exclusive. This proposal makes even less sense in that context.

Primary constructors are very specifically supposed to benefit those small data record types. You already have a fully functional constructor syntax for these larger and more complicated classes.

[DavidArno]

@HaloFour,

How would they be mutually exclusive? When records were last being discussed, I got the impression the team were looking at default behaviour that could be overridden. So I could use the record syntax to generate "larger / more complex applications that usually have have some form of dependency injection and a large constructor parameter list" as @mharthoorn describes:

public class 4DPoint(double W, double X, double Y, double Z)
{
    public double W {get; set} // overridden the default read-only property
    ...
    // as much code as you want add
}

[HaloFour]

@DavidArno

I had read it as if the goal was to provide both a dependency-injection constructor as well as a "regular" constructor which could be invoked manually to pass data values. If the intent was to just replace a dependency-injection constructor then yes, primary constructors don't exclude that possibility.

[VanKrock]

@DavidArno It's cool, all constructor's parameters would be public properties? Can I make X protected property?

[DavidArno]

@VanKrock,

To be clear, I'm in no way connected to the language design team, so anything I say here is purely my opinion and subject to being utterly ignored by the actual team.

That said, from previous discussions the community and some of the team have had around the subject, their seem to be lots of enthusiasm for having minimal syntax records that had sensible defaults, but that all those defaults could be overridden if desired. Thus it would seem likely that if you declared the following:

public class Point(double X, double Y)
{
    protected double X { get; set; }
}

then the compiler would respect the override and give you one public read-only property (Y) and one protected read/write property (X).

Of course, this is subject to change, eg the properties might be read/write by default, annotation might be allowed on the record declaration etc, so that the syntax to achieve the above weirdness might be:

public class Point(protected double X, readonly double Y);

Time will tell on this one. Also, be aware that records are currently pencilled in for v8 (subject to change, of course) and v8 is likely at least a year away from release.

[datvm]

I'd like to suggest a syntax similar to @DavidArno and already implemented in TypeScript:

class Point {
    
    public Point() {}
    
    // Y is declared here
    public Point(int x, protected int Y) : this(x, y, 0) {}
    
    // So it cannot be declared here again
    public Point(public int X, int y, private int Z) 
    {
        // In this example, I want to demonstrate declaring properties in
        // multiple constructor, so have to assign Y here manually
        // (because the constructor parameter does not have it declared)
        this.Y = y;
    }
    
    public void Bar() 
    {
        return this.X + this.Y + this.Z;
    }
    
}

Properties are combined from all the constructor. Whichever constructor is called will have their declared properties value assigned.

[jnm2]

Much as a want this, I'm not a fan of the X y Z casing.