C# Polymorphism

Question

Hi,
What's the difference between run-time polymorphism and compile-time polymorphism? Also, what's the difference between early binding and late binding? Examples would be highly appreciated.

Answer 1

Polymorphism in C#

Contrast with C++

Answer 2

Compile Time Polymorphism

Method overloading is a great example. You can have two methods with the same name but with different signatures. The compiler will choose the correct version to use at compile time.

Run-Time Polymorphism

Overriding a virtual method from a parent class in a child class is a good example. Another is a class implementing methods from an Interface. This allows you to use the more generic type in code while using the implementation specified by the child. Given the following class definitions:

public class Parent
{
    public virtual void SayHello() { Console.WriteLine("Hello World!"); }
}

public class Child : Parent
{
    public override void SayHello() { Console.WriteLine("Goodbye World!"); }
}

The following code will output "Goodbye World!":

Parent instance = new Child();
instance.SayHello();

Early Binding

Specifying the type at compile time:

SqlConnection conn = new SqlConnection();

Late Binding

The type is determined at runtime:

object conn = Activator.CreateInstance("System.Data.SqlClient.SqlConnection");

Answer 3

UPDATE: Please see Eric Lippert’s comments to this answer.

In C#2 all binding is early, because C#2 is a statically-typed language. A late binding language would be one in which the method binding occurs at run time. (C#4 includes a late binding feature with the introduction of dynamic.)

I am not sure what you mean by run time vs. compile time polymorphism.

The C# compiler will determine at compile time which method overload will be called. The run-time type of an instance will determine which implementation of a particular method overload will be executed. This is still considered early binding even though it happens at run time, because the selected method is constrained to be an implementation of a specific virtual method overload, and it is not possible for such a call to generate a type-related exception such as can occur with a dynamic language and late binding.