Declarations within object initialisers

[drewnoakes]

I have some code:

var simulation = new Simulation();

var pointMass1 = new PointMass(mass: 1.0f);
var pointMass2 = new PointMass(mass: 2.0f);

simulation.Add(pointMass1);
simulation.Add(pointMass2);
simulation.Add(new Spring(pointMass1, pointMass2));

Now that I've been using C# 7 for a while and am starting to get used to declarations in new places, it feels like the following would be a clearer form of the above:

var simulation = new Simulation
{
    var pointMass1 = new PointMass(mass: 1.0f),
    var pointMass2 = new PointMass(mass: 2.0f),
    new Spring(pointMass1, pointMass2)
};

Edit Fixed the expected output code

[jnm2]

The need to reuse an object instance in object initializers has led to many a refactor away from object initializers. I would use this somewhat frequently.

[HaloFour]

Looks like this proposal is to allow for declaration/assignments to be used as expressions within collection initializers. The result of the expression is that of the assignment and that would be added to the collection. I think it would be weird to support declaration/assignments but not just assignments, and just assignments wouldn't be possible since it would be ambiguous with object initializer syntax.

@jnm2

Are you asking about some way to declare temporary variables within an object initializer? That's not what this proposal seems to be about.

[jnm2]

@HaloFour Thanks, you're right. I saw what I wanted to see.

Back to what the proposal is really about, we already have this which I use:

var simulation = new Simulation();
{
    var pointMass1 = new PointMass(mass: 1.0f);
    var pointMass2 = new PointMass(mass: 2.0f);
    simulation.Add(new Spring(pointMass1, pointMass2));
};

I'd love to be able to do this other thing too:

var simulation = new Simulation
{
    new Spring(
        var pointMass1 = new PointMass(mass: 1.0f),
        var pointMass2 = new PointMass(mass: 2.0f)),
    new Spring(
        pointMass2,
        pointMass1)
};

[HaloFour]

@jnm2

Close. Look at the original code he posted. He wants the result of the declaration assignment to also be added to the collection:

var simulation = new Simulation();
{
    var pointMass1 = new PointMass(mass: 1.0f);
    var pointMass2 = new PointMass(mass: 2.0f);
    simulation.Add(pointMass1);
    simulation.Add(pointMass2);
    simulation.Add(new Spring(pointMass1, pointMass2);
};

[jnm2]

Well, I guess we are asking for the same thing then, if it looks like this:

var simulation = new Simulation
{
    var pointMass1 = new PointMass(mass: 1.0f),
    var pointMass2 = new PointMass(mass: 2.0f),
    new Spring(pointMass1, pointMass2)
};

[DavidArno]

Since Simulation here supports Add, let's assume that PointMass and Springboth implement ISimulationPart and that Add here takes an ISimulationPart parameter. In this case, collection initializers can be used. There are then two ways of achieving something similar, using C# 7 in one case:

// version that's been possible for some time:
var pointMass1 = new PointMass(mass: 1.0f);
var pointMass2 = new PointMass(mass: 2.0f);
var simulation = new Simulation
{
    pointMass1,
    pointMass2,
    new Spring(pointMass1, pointMass2)
};

// C# 7 version:
var simulation = new Simulation
{
    new PointMass(mass: 1.0f) is var pointMass1 ? pointMass1 : pointMass1,
    new PointMass(mass: 1.0f) is var pointMass2 ? pointMass2 : pointMass2,
    new Spring(pointMass1, pointMass2)
};

I've found the expression x is var y ? y : y would work for some code solution quite a lot recently and every time, I shy away from it as the syntax is so ugly. I keep thinking that there should be some neater way of expressing "take x, expose it to later code via new variable y and return y. This could be achieved by introducing a new as pattern, that would work like:

<expression> as [var|<type>] <returned variable>

So the example code would then be:

var simulation = new Simulation
{
    new PointMass(mass: 1.0f) as var pointMass1,
    new PointMass(mass: 1.0f) as var pointMass2,
    new Spring(pointMass1, pointMass2)
};

[drewnoakes]

I had an extraneous simulation.Add within the initialiser of my original code. It's fixed now, and hope it didn't cause any confusion.

Another way of asking this question would be: why can't variable declarations with immediate assignments be treated as expressions in the general case?

As @jnm posted, why couldn't the following work?

var spring = new Spring(
        var pointMass1 = new PointMass(mass: 1.0f),
        var pointMass2 = new PointMass(mass: 2.0f));

A few years ago this would have looked horrible, but now with C# 7 showing us that declarations work within expressions without the sky falling down, it seems there could be more opportunity here -- at least from the outside looking in.

[bricelam]

I had the idea for a slight variation on @DavidArno's as syntax today:

new Table
{
    Columns =
    {
        new Column { Name = "Id" } idColumn // 😈
    },
    PrimaryKey = new PrimaryKey
    {
        Columns = { idColumn }
    }
};