Early and Late Binding in C#

Late Binding

Late binding occurs when an object is dynamic or unknown, which will only bind during run-time. Early binding is the polar opposite of late binding. In late binding compilation, the compiler does not know what kind of object it is and what the methods or properties it holds. During run-time, the object type is determined by the data it has on the right-hand side. Late binding is achieved mostly through the use of virtual methods. Because late binding requires run-time lookups, it performs slower than early binding.

Example:

Here is an example based on Late binding.

using System;
class Ninjas
{
    static void Main(string[] args)
    {
        dynamic Dyn_obj1=4;
        dynamic Dyn_obj2=5.678;
        dynamic Dyn_obj3="Ninjas";
        Console.WriteLine("The type of the above dynamic objects:");
        Console.WriteLine(Dyn_obj1.GetType());
        Console.WriteLine(Dyn_obj2.GetType());
        Console.WriteLine(Dyn_obj3.GetType());
    }
}

Output

The type of the above dynamic objects:
System.Int32
System.Double
System.String

In the above code, the Dyn_obj1 has integer type data, Dyn_obj2 has double type data, and Dyn_obj3 has string type data. However, the compiler does not resolve these problems during compilation. These dynamic objects are identified and converted into System.Int32, System.Double and System.String respectively at run-time.

Must Read IEnumerable vs IQueryable, singleton design pattern in c#

Difference between Early and Late Binding

Check out this article - Compile Time Polymorphism

FAQs

Is late binding a slow process?

Late binding is slower than early binding because it needs run-time lookups.

What is run-time binding?

Dynamic or late binding are synonyms for run-time binding. Dynamic binding simply means that the method implementation that is called is determined at run-time rather than at compile time.

How is late binding achieved in C#?

Late binding or run-time binding in C# is achieved with reflection.

Why is run-time polymorphism called late binding?

Run-time polymorphism is also known as dynamic polymorphism or late binding. In run-time polymorphism, the function call is resolved at run time. 

What is Reflection in C#?

The process of reflecting the metadata of types, methods, and fields in a code is called reflection. The namespace System.Reflection allows you to get data about loaded assemblies and their elements, such as classes, methods, and value types.

Must Read Dynamic Binding in C++

Conclusion 

In this article, we have extensively discussed the Early and Late binding in C# progarmming language. We also discuss the difference between Early and Late binding.

We hope that this article has helped you enhance your knowledge regarding the Early and Late Binding in C# and if you would like to learn more, check out our article on the Singleton Design Pattern C#, Differences Between C++ and C# and, C# interview questions for 5 years Experience.

Refer to our guided paths on the Coding Ninjas Studio platform to learn more about DSA, DBMS, Competitive Programming, Python, Java, JavaScript, etc.

Refer to the links problems, top 100 SQL problems, resources, and mock tests to enhance your knowledge.

Do upvote our blog to help other ninjas grow. Happy Coding!