解决C＃中的params

Question

What are the rules when resolving variable number of parameters passed by params ?

Suppose, that I have the code:

public void Method(params object[] objects) { }

public void Method(IMyInterface intf, params object[] objects) { }

How is Method(a, b, c) resolved, if a is a IMyInterface? Can I be sure, that C# will always try to select most matching overload?

Answer 1

This is answered by the C# language spec:

7.5.3.1 Applicable function member

[...]

• Otherwise, if MP is applicable in its normal form and MQ has a params array and is applicable only in its expanded form, then MP is better than MQ.

• Otherwise, if MP has more declared parameters than MQ, then MP is better than MQ. This can occur if both methods have params arrays and are applicable only in their expanded forms.

[...]

In your example both overloads would be applicable only in their expanded forms. Since the second has more declared parameters it would be better .

In the context of the spec, one overload being better than all the others means that the compiler selects it to bind the call, as would happen in the example under discussion (if no one overload is better than all the others, the result is a compile-time error due to ambiguity).

Answer 2

See also C# Spec. 17.5.1.4 regarding Parameter arrays

When performing overload resolution, a method with a parameter array may be applicable either in its normal form or in its expanded form (§14.4.2.1). 2 The expanded form of a method is available only if the normal form of the method is not applicable and only if a method with the same signature as the expanded form is not already declared in the same type.

Example

using System;  
class Test  
{  
   static void F(params object[] a) {  
      Console.WriteLine("F(object[])");  
   }  
   static void F() {  
      Console.WriteLine("F()");  
   }  
   static void F(object a0, object a1) {  
      Console.WriteLine("F(object,object)");  
   }  
   static void Main() {  
      F();  
      F(1);  
      F(1, 2);  
      F(1, 2, 3);  
      F(1, 2, 3, 4);  
   }  
}  

produces the output:

F();  
F(object[]);  
F(object,object);  
F(object[]);  
F(object[]);