How does the compiler choose which method to call when the input specified can be used to call more than one functions

Question

I tried the below code

class Sample
{
    public void Display(int a, float b)
    {
        Console.WriteLine("value of a = " + a);
        Console.WriteLine("value of b = " + b);
    }
    public void Display(float a, float b)
    {
       Console.WriteLine("value of a = " + a);
    }
}

class Program
{
    static void Main(string[] args)
    {
       Operation obj2 = new Operation();
       obj2.Display(5, 5);
       Console.ReadKey();
    }
}

The output is

value of a = 5
value of b = 5

How does C# compiler know which function to call??

However if the method signatures were

public void Display(int a, float b)

public void Display(float a, int b)

I get a compile time error saying Call is ambiguous. How is it that the compiler is now unable to differentiate?

Operation obj2 = new Operation(); the Operation here is the `Sample` class? — Anonymous Duck, Jul 01 '16 at 08:54
@YogitaKudva, i dont know why you will not accept the edit, your just complicating things, welcome to SO! — Anonymous Duck, Jul 01 '16 at 08:59
@Desperado : Sorry, made the change. I was working with 2 different classes so wrote the wrong class name. I made the change now — Yogita Kudva, Jul 01 '16 at 09:01
Sorry, new to posting questions to SO. So learning to add code and trying to make it presentable — Yogita Kudva, Jul 01 '16 at 09:02
see here: http://stackoverflow.com/questions/32413926/method-overloading-in-c-sharp-and-java — currarpickt, Jul 01 '16 at 09:21
This is a question about 'Method Resolution Order' that should be enough to find your answers from google. This is one potential starting place: https://msdn.microsoft.com/en-us/library/aa691336(v=vs.71).aspx — tolanj, Jul 01 '16 at 09:31

score 1 · Answer 1 · edited Jun 20 '20 at 09:12

What you are asking is how method overload resolution works. According to the C# language specification, the rule to find the best method is:

Given an argument list A with a set of argument types {A1, A2, ..., AN} and two applicable function members MP and MQ with parameter types {P1, P2, ..., PN} and {Q1, Q2, ..., QN}, MP is defined to be a better function member than MQ if

for each argument, the implicit conversion from AX to PX is not worse than the implicit conversion from AX to QX, and

for at least one argument, the conversion from AX to PX is better than the conversion from AX to QX.

When performing this evaluation, if MP or MQ is applicable in its expanded form, then PX or QX refers to a parameter in the expanded form of the parameter list.

Update

The above explanation is from the VS. NET 2003 specification, and should be considered outdated. The C# speficiation for VS 2015 can be found in the installation folder of VS 2015, at C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC#\Specifications\1033

The specification for the "better function member" reads at follows:

7.5.3.2 Better function member

For the purposes of determining the better function member, a stripped-down argument list A is constructed containing just the argument expressions themselves in the order they appear in the original argument list.

Parameter lists for each of the candidate function members are constructed in the following way:

The expanded form is used if the function member was applicable only in the expanded form.

Optional parameters with no corresponding arguments are removed from the parameter list

The parameters are reordered so that they occur at the same position as the corresponding argument in the argument list.

Given an argument list A with a set of argument expressions { E1, E2, ..., EN } and two applicable function members MP and MQ with parameter types { P1, P2, ..., PN } and { Q1, Q2, ..., QN }, MP is defined to be a better function member than MQ if

for each argument, the implicit conversion from EX to QX is not better than the implicit conversion from EX to PX, and

for at least one argument, the conversion from EX to PX is better than the conversion from EX to QX.

When performing this evaluation, if MP or MQ is applicable in its expanded form, then PX or QX refers to a parameter in the expanded form of the parameter list.

In case the parameter type sequences {P1, P2, …, PN} and {Q1, Q2, …, QN} are equivalent (i.e. each Pi has an identity conversion to the corresponding Qi), the following tie-breaking rules are applied, in order, to determine the better function member.

If MP is a non-generic method and MQ is a generic method, then MP is better than MQ.

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.

Otherwise if all parameters of MP have a corresponding argument whereas default arguments need to be substituted for at least one optional parameter in MQ then MP is better than MQ.

Otherwise, if MP has more specific parameter types than MQ, then MP is better than MQ. Let {R1, R2, …, RN} and {S1, S2, …, SN} represent the uninstantiated and unexpanded parameter types of MP and MQ. MP’s parameter types are more specific than MQ’s if, for each parameter, RX is not less specific than SX, and, for at least one parameter, RX is more specific than SX:

A type parameter is less specific than a non-type parameter.

Recursively, a constructed type is more specific than another constructed type (with the same number of type arguments) if at least one type argument is more specific and no type argument is less specific than the corresponding type argument in the other.

An array type is more specific than another array type (with the same number of dimensions) if the element type of the first is more specific than the element type of the second.

Otherwise if one member is a non-lifted operator and the other is a lifted operator, the non-lifted one is better.

Otherwise, neither function member is better.

Another good source is the explanation on C# in Depth by Jon Skeet.

How does the compiler choose which method to call when the input specified can be used to call more than one functions

1 Answers1