Why can't I use array initialisation syntax separate from array declaration?

Question

I can do this with an integer:

int a;
a = 5;

But I can't do this with an integer array:

int[] a;
a = { 1, 2, 3, 4, 5 };

Why not?

To clarify, I am not looking for the correct syntax. That I can look up. I know that this works:

int[] a = { 1, 2, 3, 4, 5 };

Which would be the equivalent of:

int a = 5;

What I am trying to understand is, why does the code fail for arrays? What is the reason behind the code failing to be recognised as valid.

Answer 1

The reason there is a difference is that the folks at Microsoft decided to lighten the syntax when declaring and initializing the array in the same statement, but did not add the required syntax to allow you to assign a new array to it later.

This is why this works:

int[] a = { 1, 2, 3, 4, 5 };

but this does not:

int[] a;
a = { 1, 2, 3, 4, 5 };

Could they have added the syntax to allow this? Sure, but they didn't. Most likely they felt that this usecase is so seldom used that it doesn't warrant prioritizing over other features. All new features start with minus 100 points and this probably just didn't rank high enough on the priority list.

Note that { 1, 2, 3, 4, 5 } by itself has no meaning, it can only appear in two places:

• As part of an array variable declaration:

  int[] a = { 1, 2, 3, 4, 5 };
  

• As part of an array creation expression:

  new int[] { 1, 2, 3, 4, 5 }
  

The number 5, on the other hand, has a meaning everywhere it appears in C#, which is why this works:

int a;
a = 5;

So this is just special syntax the designers of C# decided to support, nothing more.

This syntax is documented in the C# specification, section 12.6 Array Initializers.

Answer 2

The reason your array example doesn't work is because of the difference between value and reference types. An int is a value type. It is a single location in memory whose value can be changed.

Your integer array is a reference type. It is not equivalent to a constant number of bytes in memory. Therefore, it is a pointer to the bytes where that data is stored.

In this first line, you are assigning null to a.

int[] a;

In the next line, if you want to change the value of the array, you need to assign it to a new array.

a = new[] {1, 2, 3, 4, 5};

That is why you need the new[] before the list of values within the array if you strongly type your declaration.

int[] a = {1, 2, 3, 4, 5}; // This will work.
var a = {1, 2, 3, 4, 5}; // This will not.

However, as many of the other answers have said, if you declare it in a single line, then you do not need the new[]. If you separate the declaration and initialization, then you are required to use new[].

Answer 3

This is the syntax to initialize an int array:

var a = new int[] { 1, 2, 3, 4, 5 };

The int[] is redundant since the type can be determined by the given values in the array. So you can write:

var a = new[] { 1, 2, 3, 4, 5 };