C# Polymorphism

Question

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

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 2

A very simple and straight forward answer for the difference between compile time and run time polymorphism.

Compile Time Polymorphism - Method Overloading (Having the same method name but with different signature). Please check the video on method overloading at this URL http://csharp-video-tutorials.blogspot.com/2012/06/part-25-c-tutorial-method-overloading.html

Run Time Polymorphism - Method Overriding (Invoking the child class overridden methods at run time, using a base class reference variable is called as run time polymorphism). Please check the videos on method overriding (Polymorphism) at this URL http://csharp-video-tutorials.blogspot.com/2012/06/part-23-c-tutorial-polymorphism.html

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.

Answer 4

early binding and static binding is same.late binding and dynamic binding is same.dynamic binding means compiler will choose which method to call on runtime.static binding means compiler will choose method to call on compile time.when we use is-a relationship of inheritance and assign derive class reference to base class reference .we will allow to invoke or access only base class reference.roslyn service will provide keyword virtual,abstract and override to call derive class member by base class reference.