C# Using new[]

Question

I have a question about using new[].

Imagine this:

Object.SomeProperty = new[] {"string1", "string2"};

Where SomeProperty expects an array of strings.

I know this code snippet will work. But i want to know what it does under the hood. Does new[] makes an instance of the class object and in SomeProperty it converts it automatically to a string object?

Thanks

Answer 1

Okay, there's still a little bit of confusion here.

The inference that's going on has nothing to with the type of Object.SomeProperty, but everything to do with the types of the expressions in the array initializer. In other words, you could do:

object o = new[] { "string1", "string2" };

and o would still be a reference to a string array.

Basically, the compiler looks at an expression like this:

new[] { A, B, C, D, ... }

(where A, B, C, D etc are expressions) and tries to work out the correct array type to use. It only considers the types of A, B, C and D (etc) as the array element type. Taking this set of candidate types, it tries to find one which all the others can be implicitly converted to. If there's not exactly one such type then the compiler will complain.

So for example:

new[] { new Form(), new MemoryStream() }

will not compile - neither MemoryStream nor Form is convertible to the other. However:

new[] { GetSomeIDisposable(), new MemoryStream() }

will be treated as an IDisposable[] because there's an implicit conversion from MemoryStream to IDisposable. Likewise:

new[] { 0, 1, 3.5 } // double[]
new[] { 1, 3, 100L } // long[]

Answer 2

This is just syntactical sugar. The compiler will infer the type actually necessary here and create code that is equivalent to the explicit construct:

Object.SomeProperty = new string[] {"string1", "string2"};

There's no such thing as new[] that gets executed at runtime.

Answer 3

It is roughly translated to:

string[] $temp = new string[2];
$temp[0] = "string1";
$temp[1] = "string2";
Object.SomeProperty = $temp;

Interestingly, var x = new[] { "string1", "string2" }; works as well, it can infer x to be a string[], but var x = { "string1", "string2" }; fails.