Question

I was just reading this answer

Which overload is called and how?

by Jon Skeet and I just done understand how overload resolution gets done at compile time – How is that possible?? You dont know the type of the object till you run??

I always thought that all method calls were done at run time (late binding)

What are the exceptions to that??

I ll give an example:

public void DoWork(IFoo)
public void DoWork(Bar) 

IFoo a = new Bar();
DoWork(a)

Which method gets called here and why?

Answer 1

When a method call is encountered by the compiler the types of all the parameters are known because C# is a statically-typed language: all expressions and variables are of a particular type and that type is definite and known at compile time.

This is ignoring dynamic which slightly complicates things.

Edit: This is a response to your edit. For clarity, I translated your code into the following:

interface IFoo { }
class Bar : IFoo { }
class Test {
    public void DoWork(IFoo a) { }
    public void DoWork(Bar b) { }
}

class Program {
    static void Main(string[] args) {
        IFoo a = new Bar();
        Test t = new Test();
        t.DoWork(a);
    }
}

You are asking which method is called here (Test.DoWork(IFoo) or Test.DoWork(Bar)) when invoked as t.DoWork(a) in Main. The answer is that Test.DoWork(IFoo) is called. This is basically because the the parameter is typed as an IFoo. Let’s go the specification (§7.4.3.1):

A function member is said to be an applicable function member with respect to an argument list A when all of the following are true:

The number of arguments in A is identical to the number of parameters in the function member declaration.

For each argument in A, the parameter passing mode of the argument (i.e., value, ref, or out) is identical to the parameter passing mode of the corresponding parameter, and

for a value parameter or a parameter array, an implicit conversion (§6.1) exists from the argument to the type of the corresponding parameter, or

for a ref or out parameter, the type of the argument is identical to the type of the corresponding parameter. After all, a ref or out parameter is an alias for the argument passed.

The issue here (see the bolded statement) is that there is no implicit conversion from IFoo to Bar. Therefore, the method Test.DoWork(Bar) is not an applicable function member. Clearly Test.DoWork(IFoo) is an applicable function member and, as the only choice, will be chosen by the compiler as the method to invoke.