[Proposal][C# 9.0 / .NET 5.0] "with" expression as one-shot initializer

[CrayonPastel]

In order to augment the productivity when using LINQ to Entities. please implement with-expression not as property modification after cloning instance but as one-shot initializer.

When a new record object is defined with some of properties modified and the others copied from another
instance as follows:

var rec1 = new MyRecord { PropA = 1, PropB = 2, PropC = 3 }; // defined as record
var rec2 = rec1 with { PropC = 0 }; // Expression (A)

the preview version of C# 9.0 compiler or .NET 5.0 RC2 seems to interpret, inside of it, Expression (A) as follows:

var rec2 = rec1.Clone() as MyRecord; rec2.PropC = 0; // Expression (B)

However, I think it has to be interpreted instead as follows:

var rec2 = new MyRecord { PropA = rec1.PropA, PropB = rec1.PropB, PropC = 0 }; // Expression (C)

This is because the interpretation as Expression (B) causes an error CS8849(*) due to the procedural substitution "rec2.PropC = 0;" obstructing compilation to an expression tree so as not to work on IQueryable<T> or LINQ to Entities, even though it can work well on IEnumerable<T> or LINQ to Object.

(*) error CS8849: An expression tree may not contain a with-expression.

[HaloFour]

The with expression cannot be implemented that way without potential loss of data:

Person person = new Student { Name = "John Smith", Grade = 4.0 };
// somewhere else in code
var clone = person with { Name = "John Jones" };
Assert.IsTrue(clone is Person { Name: "John Jones", Grade: 4.0 });

The instance method is responsible for returning the correct type regardless of the source type and to initialize the internal state of the source type beyond what the initializer would be able to initializer.

Like most new language features it's unlikely it will work with expression trees.

[CrayonPastel]

What I have been expected of with-expression, for a long time, is to behave not as an instance method but as a pure record object initializer.

Since I wrote in C# 7, as follows, an expanded Clone() method to do the same thing as with-expression does and it has been working well on LINQ to Object, the current function of with-expression is just a slightly simplified substitute if it clones an instance and then rewrites some properties to work as an instance method.

var rec2 = rec1.Clone(new { PropC = 0 }) as MyRecord; // C# 7 notation equivalent to Expression (A)

When someone rejects my proposal, all I need is a reasonable clarification why with-expression cannot be implemented as a pure initializer.

[HaloFour]

That is how the with expression behaves. It uses the instance Clone method to create a copy of the object of the appropriate type and with the duplicated internal state, and then it uses initializer syntax and behavior to write the updated properties to the instance.

Existing initializer:

Person person = new Student { Name = "John Smith", Gpa = 4.0 };

// lowered to
Student $temp = new Student();
$temp.Name = "John Smith";
$temp.Gpa = 4.0;
Person person = $temp;

With initializer:

Person other = person with { Name = "John Jones" };

// lowered to
Person $temp = other.<>Clone();
$temp.Name = "John Jones";
Person other = $temp;

C# 9.0 is shipping in a matter of weeks and this was the behavior and syntax that was implemented after much debate on the subject. I don't believe that there is any opportunity to change course on the subject.

[CrayonPastel]

Thank you for your quick response and detailed explanation.

I understand you used intentionally two class types to explain an inheritance-related case and that existing-initializer steps procedurally inside as well as with-initializer. (It's quite clear and obvious ...)

I wonder why one can be an expression tree and the other cannot be allowed though both initializers use a constructor/Clone method and then set properties. Can class types be controlled or statically determined with with-expression applied after up/down-casting as follows, even if inheritance matters ?

var other = (person as Person) with { Name = "John Jones" };
var other = (person as Student) with { Name = "John Jones" };

As the recent C# development allows destructive changes for productivity, I wish with-expression would be applicable to LINQ to Entities in the future.

[HaloFour]

Can class types be controlled or statically determined with with-expression applied after up/down-casting as follows, even if inheritance matters

Not if the consumer doesn't know the type. The purpose of having the Clone method be an instance method is that the consumer doesn't have to know (or care) how the value is duplicated. The value itself controls the type that is returned and the initial state.

As the recent C# development allows destructive changes for productivity, I wish with-expression would be applicable to LINQ to Entities in the future.

Check out this issue: #158

There are a number of new features that aren't supported by expression trees (and thus can't be supported by Entity Framework or other query providers). I agree that it is a shame that the language has a divergent language dialect baked into it like it does.

[CrayonPastel]

I really appreciate your explanation and opinion, which are quite valuable. I conclude the subject.

I dream that the productivity would be drastically augmented applying such conveniences as switch-expressions or null propagating operators to LINQ to Entities, while I can easily imagine it is hard to translate them to expression trees and much tougher or unable to apply them to LINQ to Entities. On the other hand, I come to believe a relatively small improvement enables with-expressions to get applicable to LINQ to Entities.