Allow object initializers to access previously initialized values

[thargol1]

Allow object initializers to access previously initialized values

Consider this example:

public class DummyDTO
{
	public int A { get; set; }
	public int B { get; set; }
	public int C { get; set; }
}

public static class Factory()
{
	public static DummyDTO CreateDummyDTO() =>
		new DummyDTO
		{
			A = ExpensiveFunction(),
			B = AnotherExpensiveFunction(),
			C = A + B
		};
}

Currently this does not compile. This example can be difficult to implement in the compiler, because the right hand A and B could also refer to properties or fields of the Factory object.

But with a slight change of syntax, I think it can be implemented:

public static class Factory()
{
	public static DummyDTO CreateDummyDTO() =>
		new DummyDTO
		{
			A = ExpensiveFunction(),
			B = AnotherExpensiveFunction(),
			C = .A + .B
		};
}

This could compile to:

public static class Factory()
{
	public static DummyDTO CreateDummyDTO()
	{
		var tmp = new DummyDTO();
		tmp.A = ExpensiveFunction();
		tmp.B = AnotherExpensiveFunction();
		tmp.C = tmp.A + tmp.B;
		return tmp;
	} 
}

Currently I use:

public static class Factory()
{
	public static DummyDTO CreateDummyDTO()
	{
		var dummy = new DummyDTO
		{
			A = ExpensiveFunction();
			B = AnotherExpensiveFunction();
		}
		dummy.C = dummy.A + dummy.B;
		return dummy;
	} 
}

It works fine, but it is not as elegant as it could be and cannot be used in expressions.

I like the elegance of enums:

[Flags]
public enum Test
{
	A = 1,
	B = 2,
	C = A | B
}

[MkazemAkhgary]

Should this be allowed?

new Foo { A = .A+.B };

.A and .B would have the values right after constructor call is finished.

[thargol1]

new Foo { A = .A+.B };

.A and .B would have the values right after constructor call is finished.

Though that code smells and it is not what I had in mind, I think it should be allowed. If either .A or .B could be null the new null reference checks in C#8 should issue a warning.

[MkazemAkhgary]

That's right, it smells but it was a possibility I thought it's worth mentioning. I like your proposal by the way.

[SilentSin]

If new Foo { A = .A+.B }; is allowed (I agree that it seems reasonable to allow it), then the proposal isn't really about accessing previously initialised values, it's about being able to get values from the object being initialised rather than only set them.

Another thing to consider is that this would mean property getters and setters can both be used. If so, is there then any reason to prevent methods from being called? For example:

new Vector3()
{
    x = 2,
    y = 3,
    .Normalize(),
    z = 1,
};

[jnm2]

@thargol1 Declaration expressions are already championed (#973) and would help somewhat:

public static class Factory()
{
    public static DummyDTO CreateDummyDTO() =>
        new DummyDTO
        {
            A = var a = ExpensiveFunction(),
            B = var b = AnotherExpensiveFunction(),
            C = a + b
        };
}

Along this line, similar ask: #400

[thargol1]

@jnm2 I agree declaration expressions would help and it has a much wider use than object initializers. But the proposed syntax does not help the readability of the code. Or may be I just have to get used to it.

@SilentSin I think you make a valid point and I agree it should be possible.

B.t.w the dot-syntax is borrowed from the VB object initializers.