Proposal: Beyond property initialization to code block initialization

[softwaremills]

I have found this to be a really useful function:

public static T With<T>(this T control, Action<T> setup)
{
    setup(control);
    return control;
}

I generally use it when I want to do some initialization without assigning a variable, and that initialization doesn't come in the form of setting a property:

var views = new[]
{
    new View(context).With(v => v.SetBackgroundColor(color1)),
    new View(context).With(v => v.SetBackgroundColor(color2)),
    new ViewGroup(context).With(vg =>
    {
        vg.AddView(new View(context).With(v => v.SetBackgroundColor(color1)));
        vg.AddView(new View(context).With(v => v.SetBackgroundColor(color2)));
    },
};

That does work, but it annoys me that it's setting up a bunch of closure objects and functions behind the scenes for something that should be pretty simple syntactic sugar. Of course, not being a language designer, I have no idea what the proper syntax should be for this sort of thing. I imagine something like this:

var views = new[]
{
    new View(context) with v { v.SetBackgroundColor(color1); },
    new View(context) with v { v.SetBackgroundColor(color2); },
    new ViewGroup(context) with vg
    {
        vg.AddView(new View(context) with v { v.SetBackgroundColor(color1); });
        vg.AddView(new View(context) with v { v.SetBackgroundColor(color2); });
    },
};

I mean, I use my little helper With() in places, but I still cringe. And I find this pattern so useful all over the place, especially where you're building some complex data structure and it's not sufficient to use property initialization or collection initialization.

[iam3yal]

@softwaremills C# has the concept of object initializers, maybe this concept can be expanded.

So it would be something like this:

var views = new[]
{
    new View(context) { SetBackgroundColor(color1) },
    new View(context) { SetBackgroundColor(color2) },
    new ViewGroup(context) {
        AddView(new View(context) { SetBackgroundColor(color1) }),
        AddView(new View(context) { SetBackgroundColor(color2) })
    },
};

[softwaremills]

@eyalsk That might get most of the way there. I like having the named reference to be able to have the full capability of blocks, like being able to, say, pass the ViewGroup to the created subviews, but your syntax is indeed closer to existing C#. In the With calls in my existing codebase, 16 out of 27 cases would be covered by that syntax. Some cases wouldn't be covered because of ifs or foreaches in the block. Some wouldn't be covered because the With call doesn't actually have to be a new; it works just fine with any expression.

For instance, here's an actual snippet from my codebase:

new UpdateShiftsData {
	DeletedBids = bids.Map(b => b.BidId),
	EditedShifts = new[] {
		new ShiftData {
			ShiftId = shift.ShiftId,
			WorkerId = bid.WorkerId,
			UpForBid = false,
			BidDeadlineMins = null,
			ModifiedDate = now,
		}.With(sd => {
			if (bid.SubShiftStart.HasValue) sd.Start = bid.SubShiftStart;
			if (bid.SubShiftFinish.HasValue) sd.Finish = bid.SubShiftFinish;
		}),
	},
}.With(usd => {
	if (recalculateBreaks) {
		usd.DeletedBreaks = breaks.Map(b => b.BreakId);
		usd.AddedBreaks = applyBidBreaks.Map(b => new BreakData(b));
	}
}).ToJObject()

[ufcpp]

with-expressions in https://github.com/dotnet/csharplang/blob/658e65403a9e14d9f614994d1fd6757d4fab9608/proposals/records.md

[softwaremills]

@ufcpp That is a good point; any proposed changes would need to be compatible with the syntax in records and, in particular, the with-expressions you mention. Good call.

This is quite different than records, of course, which are meant to enable good practices in immutable structs. This proposal is meant to refer to taking any expression, providing a block that operates on that expression, with the whole thing evaluating to the original expression. The syntax would ideally be general-purpose syntax that would be very useful for building complex literals. Such things happen a lot in the creation of data structures to be serialized (as in my code snippet above) or, possibly, applied to user interfaces (say, for instance, the creation of React-like virtual stand-in elements).

[tomschrot]

Kotlin supports a similar construct, and has the automatic "it" variable in the callers' context for such closures.

I use such a extension for years, but naming it apply, config, utilize ....

The mechanism is also very useful as constructor and could replace the object initializer with the advantage to access the methods also.

`
var y = new XY (my =>
{
my.value = 10;
...
});

class XY
{
public XY () {}
public XY (Action treat) => treat (this);

public int value {get; set;} = 0;

}
`

[TahirAhmadov]

There was extensive discussion just about such a request raised by @najak3d in #5728. I'm also interested in the performance penalty of using these simple lambda callbacks in a method like With. Have you considered running a benchmark to measure the performance penalty (if any)? Does it make sense to raise this a request for the JIT team to add an optimization for this? Did you look into using static lambdas to reduce this penalty?

[najak3d]

I like your proposes "with" syntax. This seems intuitive and effective to me:
(your example here)

var views = new[]
{
    new View(context) with v { v.SetBackgroundColor(color1); },
    new View(context) with v { v.SetBackgroundColor(color2); },
    new ViewGroup(context) with vg
    {
        vg.AddView(new View(context) with v { v.SetBackgroundColor(color1); });
        vg.AddView(new View(context) with v { v.SetBackgroundColor(color2); });
    },
};

If this my proposal #5728 were approved, it would handle your notation for this example like this:
(Just omit the "with {variableName}", trailing ";" and just use "." to designate 'this'.)

var views = new[]
{
    new View(context) { .SetBackgroundColor(color1) },
    new View(context) { .SetBackgroundColor(color2) },
    new ViewGroup(context)
    {
        .AddView(new View(context) { .SetBackgroundColor(color1) }),
        .AddView(new View(context) { .SetBackgroundColor(color2) })
    },
};

But my proposal would not handle the more complex logic that you sometimes run now (e.g. with "if" statements, etc). For those, you'd still need your "with" syntax (or continued use of an Extension method).