Primary constructors in C# vnext

Question

The Language feature implementation status was brought to my attention via C# Chat. I have a couple of questions about some of the features not covered in this existing question.

Some of the new features are obvious such as Getter-only auto-properties

public int Y { get; } = y;

... awesome.

But others I am not clear on...

---

Primary constructors

class Point(int x, int y) { … }

It may be a gap in my knowledge, but I haven't come across the term "primary constructor" before, but some research seems to suggest that basically this is a shortcut for defining the following

class Point
{
    private int x;
    private int y;

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

• Is this the correct interpretation?
• Does this mean you can still do constructor overloads (the term "primary" implies so)?
• Can you refer to these implicit backing fields in other constructors/methods?

Answer 1

• Is this the correct interpretation?

Almost, but not exactly. By default, primary constructor parameters are not captured into fields; they are, however, accessible in instance member initializers (and only there), so you can explicitly initialize fields or properties with them:

class Point(int x, int y)
{
    public int X { get; } = x;
    public int Y { get; } = y;
}

(note that in this case, backing fields are created, but for the properties, not the constructor parameters)

But you can also declare the parameters with access modifiers, in which case they will be captured as fields, and be accessible from all instance members:

class Point(public readonly int x, public readonly int y)
{
}

(as you can see, you can also specify other modifiers for the fields, like readonly)

• Does this mean you can still do constructor overloads (the term "primary" implies so)?

Yes, you can have other, non-primary constructors. However, they're all required to call the primary constructor, with the usual : this(...) syntax.

• Can you refer to these implicit backing fields in other constructors/methods?

As mentioned above, there are no implicit backing fields; the backing field is only created if you explicitly specify an access modifier on the primary constructor parameter.

---

EDIT: this feature has been withdrawn and won't be in C# 6 (probably in C# 7, in a slightly different form)