Compile time polymorphism vs. run time polymorphism

Question

Why is overloading called compile time polymorphism and Overriding run time polymorphism in C#?

Answer 1

Well, overloading decisions (which method signatures are used, based on the arguments¹) are made by the compiler, whereas overriding decisions (which method implementations are used, based on the type of the target of the method) are made by the CLR at execution time.

I wouldn't usually call overloading "polymorphism" though. In my experience the word usually refers to overriding. I suppose overloading does allow you to treat an object of one type as another, although overloading itself doesn't need to be involved there - it's just normal type conversions.

Here's an example showing that overload choice is performed at compile time:

using System;  class Test {     static void Foo(object a)     {         Console.WriteLine("Object overload called");     }      static void Foo(string a)     {         Console.WriteLine("String overload called");     }      static void Main()     {         object x = "hello";         Foo(x);     } } 

Here the Foo(object) overload is called because x is of type object at compile time - it's only at execution time that it's known to refer to a string.

Compare that with this example:

using System;  class Base {     public virtual void Foo()     {         Console.WriteLine("Base.Foo called");     } }  class Derived : Base {     public override void Foo()     {         Console.WriteLine("Derived.Foo called");     } }  class Test {     static void Main()     {         Base x = new Derived();         x.Foo();     } } 

Here the compile-time type of x is Base, but it's still the derived class's overriding method which is called, because the execution-time type of the object that x refers to is Derived.

---

¹ It's slightly more complicated than that in fact, due to method hiding etc - but in simple cases you can think of it as just picking the signature.

Answer 2

Overridden functions are functions that have the same signature, but are implemented in different derived classes. At compile time, usually the base class type is used to reference an object, though at run time this object could be of a derived type, so when an overridden method is called, the implementation that is called is dependent on what kind of object is doing the calling (base vs. a derived type) which is unknown at compile time.

Overloading (not really polymorphism) is simply multiple functions which have the same name but different signatures (think multiple constructors for an object taking different numbers of arguments). Which method is called is known at compile time, because the arguments are specified at this time.