More or less equal overloads

Question

The following code compiles in C# 4.0:

void Foo(params string[] parameters) { }
void Foo(string firstParameter, params string[] parameters) { }

How does the compiler know which overload you're calling? And if it can't, why does the code still compile?

Answer 1

In some cases, it will decide for you. So, you might want to use different names in cases like this (or in more useful cases :-) ).

In particular, out of the four cases:

        Foo("bar");
        Foo("bar", "bar");
        Foo(new string[]{"bar", "bar"});
        Foo("bar", new string[] { "bar", "bar" });

only #1 and #2 are 'ambiguous' (since #3 and #4 naturally match overload 1 and 2 respectively).

In cases #1 and #2 overload resolution chooses overload #2, because it has a standalone string parameter that matches the only/first parameter of the invocation.

Answer 2

It is well specified in the C# Language Specification, chapter 7.4.3.2, "Better 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 fewer 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.

Fwiw, the C# Language Specification is a very readable document and can help you resolve these puzzles by yourself. You have it on your machine, find it back in the Visual Studio install directory (like c:\program files\microsoft visual studio 9.0) in the vc#\specifications\1033 subdirectory.

Another good one is the Ecma-335 standard document, freely available as a PDF download. It specifies the behavior of the CLR and the JIT compiler, great material to understand why C# (and the CLR) do what they do. Recommended.