[Proposal] C# Next - What does Record/Data types corresponding interfaces / inheritance mean?

[BrianBu01]

I'm not sure what the thoughts are around defining a record/data as an interface. Lets call this construct a "register" for a lack of a better term right now. Records/Data are cool, but I feel some inheritance is warranted

Base Constructs

public register IIndividual { string FirstName; string LastName }

public data Employee : IIndividual { string Title; int Salary }

public data Contact : IIndividual { string PhoneNumber; }

Data Record Type Changes

Potentially we could use with expressions to only copy the known elements.
The first method here is the way I think about it with the current constructs.
The second and third methods is how I think it should mature. Maybe Yoda speak here is more readable.

public Contact CreateContactInfo(IIndividual individual, string phoneNumber)
{
    return (individual as Contact) with { PhoneNumber = phoneNumber };
}

public Contact CreateContactInfo(IIndividual individual, string phoneNumber)
{
    return individual with { PhoneNumber = phoneNumber } into Contact;
}

public Contact CreateContactInfo(IIndividual individual, string phoneNumber)
{
    return individual into Contact with { PhoneNumber = phoneNumber };
}

As Extension methods?

Just moving down the natural progression here. Maybe it makes sense...
Maybe it would be going backwards.

public static Contact CreateContactInfo(this IIndividual individual, string phoneNumber)
{
    return individual with { PhoneNumber = phoneNumber } into Contact;
}

Anonymous Records/Data auto implementing

I personally would love to see Anonymous Class being converted into the construct, or auto projected...
This is a lot but the anonymous class created at compile time would just have to implement IIndividual.
The following three methods are just a natural progression in my mind of removing unnecessary items.

public IEnumerable<IIndividual> GetData()
{
    return from x in datasource
        new data { FirstName = x.FirstName, LastName = x.LastName } into IIndividual;
}

public IEnumerable<IIndividual> GetData()
{
    return from x in datasource
        new data x into IIndividual;
}

public IEnumerable<IIndividual> GetData()
{
    return from x in datasource into IIndividual;
}

Just a thought. I always hated that anonymous classes were bound to the local class. I felt records with the read only POCO constructs could allow for a bit more enhancements.

[YairHalberstadt]

Is the only difference with normal interfaces that you can with them?

[BrianBu01]

@YairHalberstadt For the first part kindof.

The notable change between is stripping of values when doing the type change.

For:

public Contact CreateContactInfo(IIndividual individual, string phoneNumber)
{
    return (individual as Contact) with { PhoneNumber = phoneNumber };
}

Passing in a Employee record should strip out the un-used data properties, and pass along the IIndividual properties into Contact.

So passing in

CreateContact(new Employee {
FirstName = "Ada",
LastName = "Lovelace"
Salary = "100000"
}, "555-555-555");

would return a Contact without Salary.

I'd assume also the argument passing for the method would actually do a property clone and convert it as a value type.

For:

public IEnumerable<IIndividual> GetData()
{
    return from x in datasource
        new data { FirstName = x.FirstName, LastName = x.LastName } into IIndividual;
}

The Compile would have to create an Anonymous Type of data that also implements IIndividual. Right now there is no way to not manually define an Interface as a concrete implementation and still use it.

[BrianBu01]

So

var employee = new Employee 
{
    FirstName = "Ada",
    LastName = "Lovelace"
    Salary = "100000"
};

var individual = Employee into IIndividual;

the into to me creates a second data object. So the two values are not equivalent.

employee != individual

but value equality would be the same if you add back the Salary.

employee == individual with { Salary = "100000" } into Employee

[HaloFour]

Records support inheritance:

public record Individual
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

public record Employee : Individual
{
    public string Title { get; init; }
    public int Salary { get; init; }
}

public record Contact : Individual
{
    public string PhoneNumber { get; init; }
}

There have been requests to have anonymous classes implement interfaces and the language design team hasn't expressed much interest in the idea. dotnet/roslyn#13 (comment)

But the team has expressed interest in expanding with to non-records.

[BrianBu01]

Interesting on the anonymous interfaces.

If you look at Concerns in that thread, record types all but resolve all of the concerns.

Time to revisit it?

[HaloFour]

I would think that the interest in expanding with to non-records would cover what you're requesting here, assuming the interface can be amended to include the required members. That may require changing the interface to look something like this:

public interface IIndividual
{
    string FirstName { get; init; }
    string LastName { get; init; }
    IIndividual Clone();
}

Also, there is interest in making anonymous classes into anonymous records, including with support, since they already have value equality.