Can with be allowed with regular classes?

[TahirAhmadov]

class Class
{
  public int Prop1 { get; set; }
  public string? Prop2 { get; set; }
}
var c = new Class { Prop1 = 123, };
var c2 = c with { Prop2 = "abc", }; // can this be allowed?

[Joe4evr]

I know that the language team definitely had it on the table to enable such scenarios without explicitly using records, but I guess because the prerequisite feature got punted, this is also delayed.

[TahirAhmadov]

Just curious, what was that prerequisite feature?

[Joe4evr]

While the exact naming (and implementation) is TBD, it comes down to making the compiler aware a method is specifically a factory:

[Factory] // the compiler now only allows a 'new' expression or other '[Factory]'-annotated method call to be the return value of this method
public static Foo Create(/*....*/)

enabling the use of object initializers without being restricted to new expressions:

var foo = Foo.Create() { Bar = 28 };

Now, similar to how the compiler already duck-types for LINQ query syntax, once the above feature is in, the compiler could specially recognize if a member is

[Factory]
public Foo With() { }

and then that will allow the use of with on variables of this type while not requiring the whole type itself to be a record.

[HaloFour]

IIRC the problem is that the method used by with needs to follow an enforced convention otherwise the feature will result in decapitation:

class A {
    public string Foo { get; set; }
}

class B {
    public string Bar { get; set; }
}

A x = new B() { Foo = "foo", Bar = "bar" };

var y = a with { Foo = "fizz" }; // the compiler only knows that x is an A here
Debug.Assert(y is B); // oops, y is an A, not a B

[HaloFour]

Structs don't have this problem which is why structs do not support with. So do anonymous types.

[Joe4evr]

I believe you mean that “structs do support with“ now. 😉

Also, in the case of the explicit method, if it's required to be virtual (for non-sealed classes) and the return type must be the containing type (which is how it's shown working in the slides), there's no more problem.

[HaloFour]

Fixed my comment. 😅

Right, the method has to be virtual, must be implemented by every non-abstract deriving class and must have a covariant this return type. IIRC, covariant return type support was added originally to support this.

[TahirAhmadov]

So it looks like there are prerequisites here - 1, [Factory] attribute, and 2, covariant return types? Are there issues/discussions to track those? Thank you for the info.

[jods4]

That would actually be nice!

The key "issue" of with is knowing how to clone the original instance before re-assigning members.

I think C# could look for the following support:

• The type is ICloneable -> use ICloneable.Clone.
• Duck-type an instance Clone() method. Possibly consider extension methods for types you don't fully control. (A naive extension method would probably not support derived types properly, but that's up to the implementer/user. And sometimes there's no derived type.)
• Fallback to Object.MemberwiseClone(), which creates a shallow copy of any object.

I wonder what the perf of MemberwiseClone is. In theory, the JIT could just copy all bits from source objects to destination, which would be super efficient, moreso than doing a one-by-one copy. And the callsite codegen would be much smaller. Apparently C# doesn't use it when it generates record types, so I guess there has to be a drawback.

---

I'm getting side-tracked but having this feature on any class and allowed inside Expression trees would be greatly beneficial to projects like linq2db.
I am aware that Expression is a "done" API, which I just don't understand given that no replacement was proposed and it's the backbone of a lot of .net libs, esp. LINQ implementations but also code compilers and more.