Trouble Emitting Object Array using Reflection.Emit

Question

I am trying to Emit what I thought would be a simple object array that would result in code similar to the below example

object[] parameters = new object[] { a, b, };

When I write the above code in C# using VS, I get the following IL. As expected this works.

.locals init (
[0] object[] parameters,
[1] object[] CS$0$0000)

However, when I try and Emit IL directly, I only ever get a one index init array. Can someone help tell me where I've gone wrong here?

Here is the Emit code I'm using:

int arraySize = 2;
LocalBuilder paramValues = ilGenerator.DeclareLocal(typeof(object[]));
paramValues.SetLocalSymInfo("parameters");
ilGenerator.Emit(OpCodes.Ldc_I4_S, arraySize);
ilGenerator.Emit(OpCodes.Newarr, typeof(object));
ilGenerator.Emit(OpCodes.Stloc, paramValues);

Here is the resulting IL:

.locals init (
[0] object[] objArray)

The rest of the resulting IL is identical between the two solutions, but for some reason the .locals init is different.

Answer 1

If you declare only one local (paramValues) then there will be only one local declared. Call DeclareLocal another time if you need a second local. But I don't understand why you'd need this? There is no sense in declaring locals that you don't need.

Answer 2

The CS$0$0000 variable is here because the compiler didn't optimize variable creation/usages. It uses this automatically created variable for the new object[] { a, b, } part of the code, and then assigns the created object to the object[] parameters variable. This behaviour is mostly beacuse of the stack-based nature of IL. Try running the code in Release mode an see if it gets optimized.

Answer 3

The C# compiler generates code like this:

object[] temp = new object[2];
temp[0] = (object)a;
temp[1] = (object)b;
parameters = temp;

The temp variable is the CS$0$0000 you see. I think it does this to ensure that an exception that might be raised while initializing the array doesn't leave a partially initialized array in "parameters". Which could cause unexpected failure when code catches the exception. As written, the named variable is either null or fully initialized. Good idea.