Shorthand for positional record inheritance

[orthoxerox]

I swear I remember this being discussed, but couldn't find the issue/discussion.

I find myself writing records that repeat the same parameters over and over again, e.g.:

abstract record Person(string Name, double Weight, double Height, DateTime DateOfBirth, BloodType BloodType, Gender Gender);

record Student(string Name, double Weight, double Height, DateTime DateOfBirth, BloodType BloodType, Gender Gender, Major Major, double Gpa) 
    : Person(Name, Weight, Height, DateOfBirth, BloodType, Gender);

record Professor(string TermOfAddress, string Name, double Weight, double Height, DateTime DateOfBirth, BloodType BloodType, Gender Gender, Faculty Faculty, bool Tenured) 
    : Person(Name, Weight, Height, DateOfBirth, BloodType, Gender);

//10 more derived records

Yes, there exist cases when I do not include every single parameter from the base record's primary constructor in the derived record's primary constructor or do not pass them as-is, but they are definitely in the minority. I propose a token that can both go into the derived record's primary constructor to show that it contains every parameter from the base record's primary constructor and that can go into the inheritance clause to avoid repetition (and show that we're not trying to call the parameterless constructor if it exists), e.g. ...:

abstract record Person(string Name, double Weight, double Height, DateTime DateOfBirth, BloodType BloodType, Gender Gender);

record Student(..., Major Major, double Gpa) 
    : Person(...);

record Professor(string TermOfAddress, ..., Faculty Faculty, bool Tenured) 
    : Person(...);

//10 more derived records

[333fred]

I view this as more of a use case for adding required properties to the language to make nominal records a viable solution here, personally. Positional constructors are just brittle across hierarchies, particularly when you start mixing multiple assemblies into the mix, and I'd prefer to investigate nominal properties as the solution.

[Richiban]

I also vaguely remember this...

I'm really not sure though why you're using positional records in this case. Isn't a positional record normally thought of as essentially a tuple, with the usual rule-of-three holding true?

With required properties this should cease being an issue.

[MgSam]

I was thinking recently that this part of the records proposal seems to have disappeared at some point.

The ... feature for calling the base constructor deserves to be looked at independent of records. There is a fundamental brittleness with constructors and inheritance that ... could potentially help solve. This is widespread problem not just in C# but in many other OOO languages as well. If C# could come up with a great solution here it could very well set an example for other languages to follow.

Inheritance, especially in a framework using constructor Dependency Injection, can be a pit of failure because of the base class brittleness.

In places where I know there will be an expandable inheritance hierarchy I often prefer using "property bag" types these days rather than "real" constructor parameters (or interface/abstract method parameters...). That way, adding a new property won't instantly break all implementors.