Can't understand why array initializer in object initializer cannot compiled

Question

I saw NRE when using array initializer in object initializer and there was a update and https://github.com/dotnet/roslyn/wiki/New-Language-Features-in-C%23-6#extension-add-methods-in-collection-initializers but still I cannot understand.

var arr = new int[] { 1, 2, 3 } generate IL code using stelem. But int[] arr = { 1, 2, 3 } generate IL code using RuntimeHelpers.InitializeArray. I think it is using Array.Add extension method which was talk in that answer.

But in object initializer, all array initializer generate second code. An example,

new A() { 
    arr = new int[] { 1, 2, 3 }
}

Array arr is created using RuntimeHelpers.InitializingArray too. Then, doesn't it mean there isn't any problem in next code?

new A() {
    arr = { 1, 2, 3 } // Compiler error!
}

Not like old version of c# compiler, it makes compiler error saying system.array does not contain a definition for Add. What's happening?

EDIT I thought just syntax without new [] makes differences but actually more than three elements makes different IL code.

Answer 1

The second syntax ( { arr = {... } }) is syntax sugar for sequence of value.arr.Add(.) - presumably value.arr is not initialized in your constructor and hence NRE.

Assuming A is:

class A { 
     public int[] arr {get;set} 
}

then

var x = new A() {
    arr = { 1, 2, 3 } // Compiler error!
};

is the same as

var x = new A(); // note x.arr is default null here
x.arr.Add(1);  // NRE is arr is list, can't compile for int[]
x.arr.Add(2);
x.arr.Add(3);

Fix: use list, there is no reasonable way to add elements to an array. If using some other type that does not have .Add - implement extension method that is visible to that code.

Why version with new works:

var x = new A() {
    arr = new int[] { 1, 2, 3 } 
};

is equivalent^* of

var x = new A();
x.arr = new int[] { 1, 2, 3 };

Note that in array initializer you can use both syntaxes to the same effect, but not in array field's initializers (All possible C# array initialization syntaxes)

int[] x = { 10, 20, 30 }; // valid, same as int[] x = new int[]{ 10, 20, 30 };

while new A { arr = { 10, 20, 30} } is not the same as new A { arr = new int[3]{ 10, 20, 30} }

---

_{^*It is really a bit more complicated to satisfy rules when change must be observable - see Eric Lippert's comment below}

Answer 2

In an expression context these are legal array values:

new int[3] { 10, 20, 30 }
new int[] { 10, 20, 30 }
new[] { 10, 20, 30 }

In a local or member variable initializer context, this is a legal array initializer:

int[] x = { 10, 20, 30 };

And this is a legal collection initializer:

List<int> x = new List<int> { 10, 20, 30 };

And, if X<T> is IEnumerable<T> and has a method Add(T, T, T), this is legal:

X<int> x = new X<int> { { 10, 20, 30}, {40, 50, 60} };

But in a member or collection initializer context this is not a legal array property initializer:

new A() {
    arr = { 10, 20, 30 }
}

(Note that I summarize and comment on the rules for arrays here https://stackoverflow.com/a/5678393/88656)

The question, as I understand it, is "why not?"

The answer is "no good reason". It's simply an oddity of the C# grammar and the rules for object and collection initializers.

I many times considered fixing this oddity but there was always something better to do with my time; it's a fix that benefits basically no one because the workaround is so easy.

I conjecture that there's nothing stopping the C# team from designing, specifying, implementing, testing and shipping that feature aside from the fact that there are still about a million other features that would be a better use of their time.

If you feel strongly about it, well, the compiler is open source; feel free to propose the feature and advocate for it. Or, for that matter, implement it and submit a pull request. (After you propose the feature.)

Until the feature you want is implemented you'll just have to use one of the three "expression" forms listed above. It is not burdensome to do so.