[Proposal] Designated initializers for arrays

[prenone]

Designated initializers

A great description of designated initializers is given in the first lines of https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html

Implementation

The use of designated initializers should be implemented to be used like this:

int[] array = new int[5]
{
  [0] = 1,
  [3] = 1
};

which will give an array equivalent to int[] array = new int[5] {1, 0, 0, 1, 0 };

Values of indexes that are not specified in the designated implementation (1, 2, 4 in the example) should be initialized to the default inner type value.

This should also work with multidimensional arrays:

int[,] matrix= new int[2,2]
{
  [1,1] = 1,
  [0,1] = 1
}

which will give an array equivalent to int[,] matrix = new int[2,2] { {0, 1}, {0, 1}}.

and jagged arrays:

int[][] jagged = new int[2][]
{
  [0] = { 1, 2, 3},
  [0][1] = 6, //This is ok as jagged[] was initialized in the preceding line
  [1][0] = 5  //This should rise a NullReferenceException because jagged[1] is initialized to null by default. 
}

Alternatives

The obvious alternative to designated initializations is assigning values after the array has been initialized

//Without designated initializations
int[] normal_array = new int[3];
normal_array[0] = 1;

//With designated initializations
int[] cool_array = new int[3] { [0] = 1 };

I apologize for any miscomprehension or error I generate, I am just now gaining experience with GitHub

[YairHalberstadt]

This is already legal for any other type with an indexer (e.g. dictionary). I think this makes perfect sense purely for consistency.

[prenone]

Exactly. I am also confused because according to Arrays as Objects (C# Programming Guide)

arrays are actually objects, and not just addressable regions of contiguous memory as in C and C++.

and thus should have an indexer implemented (in the abstract Array class) that is accessible during initializations.
I am guessing this doesn't work because the array initialization isn't treated as an object initialization

int[] array = new int[] { 0, 1, 2, 3 }; //In this case the content between { } is translated to an array by the compiler

Dictionary<int, int> dictionary = new Dictionary<int, int>() { [0] = 1, [1] = 1 }; //however here the content between { } refers to members of the dictionary object

Can anyone confirm?

[HaloFour]

Array initializers are necessarily different from collection initializers. Collection and indexer initializers came much later in the language and both assume that the collection is responsible for allocation space to add the new elements as they are added. Arrays need to know their size up-front, and array initializers can infer the size based on the elements, so it makes sense that they play by different rules.

I could see indexer initializers working with arrays, but I think that the language would have to require that you specify a size. Question is whether or not there's enough value in actually doing that. It's not enough to make it seem more consistent, especially when it can't be consistent.

[prenone]

Yes, array size should be specified before using a designated initializer.
The fact that it may not add enough value is actually true. I personally thought about it because I actually needed it: I had a 25x25 array of booleans of which only [21][21] and [22][22] needed to be true. But this is extremely specific.
In general, I think the only value this could add is syntactic sugar for the case I explained in the Alternatives section of the original post, which is analogous to the one in my experience.

[prenone]

Also, again personally, I think consistency should be important between arrays and collections, as they are essentially both groups of elements with very similar syntax.

[HaloFour]

C# is loaded with inconsistencies, many of them necessary. Even here an indexer initializer for an array would have to be a special case because arrays aren't like other collections and array initializers aren't like collection initializers.

[prenone]

I think many implemented things are special cases, it is a matter of wheter it would make sense to allow this specific special case.
I agree about the inconsistency of many things in C#, however I think this would make many things easier, and I can't see any obvious downsides either.

[HaloFour]

@prenone

and I can't see any obvious downsides either.

Cost :)

Modifying the language is very expensive. If a feature doesn't have sufficient upsides it generally doesn't get considered.

I do agree, other than dealing with requiring a size for the array (which is already an inconsistency with array initializers), this doesn't seem terribly controversial, but it's up to someone on the language team to deem it worth of triaging it and considering it for the language.

[prenone]

Oh yes, sorry, that is most definitely true😅. I agree that it is up the team of course, also I wouldn't consider the proposed feature nor critical nor game-breaking, just something convenient.

[huoyaoyuan]

Note: this feature is somehow useful with enums:

static readonly int[] fastEnumMap = new int[]
{
    [(int)MyEnum.A] = 1,
    [(int)MyEnum.B] = 2,
};

[prenone]

I think this would be redundant as you can give a intger value to your enum component when declaring them. However it could be interesting to see it done with a different type. E.g

string readonly int[] fastEnumMap = new string[]
{
    [(int)MyEnum.A] = "apple",
    [(int)MyEnum.B] = "orange,
};

EDIT: I think that Dictionary better suits this need as it also preserve the enum type

[Avid29]

A dictionary has overhead. I realize C# isn't generally written with that level of need to be performant, but having a dictionary of enums to strings seems wasteful when the enums can be treated as indices in an array and initialized like this.

[Avid29]

I just came to open this exact same discussion with the exact same proposal.

5 years later, any interest?