C＃使用params关键字的结果不一致

Question

Given the following method:

static void ChangeArray(params string[] array) {

    for (int i = 0; i < array.Length; i++) 
        array[i] = array[i] + "s";
}

This works if I call it passing a array of strings:

string[] array = {"Michael", "Jordan"} // will become {"Michaels", "Jordans"}
ChangeArray(array);

But will not work if I call it using string arguments:

string Michael = "Michael";
string Jordan = "Jordan";
ChangeArray(Michael, Jordan); // This will NOT change the values of the variables

I understand that the compiler will wrap Michael and Jordan on an array, so shouldn't the results be the same on both cases?

Answer 1

Your second example is essentially:

string Michael = "Michael";
string Jordan = "Jordan";
{
    var tmp = new string[] {Michael, Jordan};
    ChangeArray(tmp);
}

so; actually, the values inside tmp were changed... but tmp was discarded afterwards, so you don't see anything. params does not emulate ref - it won't do a position-wise update back into the original variables. Or in code, it is not the following:

string Michael = "Michael";
string Jordan = "Jordan";
{
    var tmp = new string[] {Michael, Jordan};
    ChangeArray(tmp);
    Michael = tmp[0];
    Jordan = tmp[1];
}

If you need it to behave like that, then code it like that - or use instead an overload that takes ref parameters.

Answer 2

The reason is that string is an immutable type - you pass in string instances that get wrapped in an array. The array now contains two new strings (with the same values that the original ones but different instances). When you change the array, these copies are throw away and the array slot will hold a new string. When your function returns, the temporary array is thrown away. Thus your original input strings are never modified (they couldn't be anyway, since string is - again - immutable).

Edit I made an edit to this answer following Lee's argument in the comments (I'll leave the answer as is simply to keep the following discussion complete). The immutable part is indeed irrelevant to the problem. The main underlying issue is that changes are made to the temporary array that's thrown away.

Answer 3

This is weird (I didn't know this), but as specified .

A parameter array permits arguments to be specified in one of two ways in a method invocation:

The argument given for a parameter array can be a single expression of a type that is implicitly convertible (Section 6.1) to the parameter array type. In this case, the parameter array acts precisely like a value parameter.

Alternatively, the invocation can specify zero or more arguments for the parameter array, where each argument is an expression of a type that is implicitly convertible (Section 6.1) to the element type of the parameter array. In this case, the invocation creates an instance of the parameter array type with a length corresponding to the number of arguments, initializes the elements of the array instance with the given argument values, and uses the newly created array instance as the actual argument.