Early and late binding in C#

When an object is assigned to an object variable of the specific type, then the C# compiler performs the binding with the help of .NET Framework. C# performs two different types of bindings which are:

Early Binding

It recognizes and checks the methods, or properties during compile time. In this binding, the compiler already knows about what kind of object it is and what are the methods or properties it holds, here the objects are static objects. The performance of early binding is fast and it is easy to code. It decreases the number of run-time errors. Example: 

// C# program to illustrate the

// concept of early binding

using System;


class Geeks {


// data members

public string name;

public string subject;


// public method

public void details(string name, string subject)

{

this.name = name;

this.subject = subject;

Console.WriteLine("Myself: " + name);

Console.WriteLine("My Favorite Subject is: " + subject);

}

}


// Driver class

class GFG {


// Main Method

static void Main(string[] args)

{


// creating object of Geeks class

Geeks g = new Geeks();


// Calling the method of Geeks class

g.details("Ankita", "C#");


// Calling "mymethod()" gives error

// because this method does not 

// belong to class Geeks or compiler 

// does not know mymethod() at compile time

g.mymethod();

}

}

Compile-Time error:

prog.cs(34, 5): error CS1061: Type `Geeks’ does not contain a definition for `mymethod’ and no extension method `mymethod’ of type `Geeks’ could be found. Are you missing an assembly reference? prog.cs(5, 7): (Location of the symbol related to previous error)

Explanation: In the above example, we have a class named as Geeks. This class contains details() method. Here, the compiler already knows about the properties and methods present in Geeks. But when we try to call mymethod() then it will throw an error because this method is not known by the compiler.

Late Binding

In late binding, the compiler does not know about what kind of object it is and what are the methods or properties it holds, here the objects are dynamic objects. The type of the object is decided on the basis of the data it holds on the right-hand side during run-time. Basically, late binding is achieved by using virtual methods. The performance of late binding is slower than early binding because it requires lookups at run-time. Example: In the below, program the obj holds integer type data and obj1 holds double type data. But the compiler doesn’t resolve these at compile-time. At the runtime, these dynamic objects get detected and converted into System.Int32 and System.Double respectively. Thats why the run-time resolving process is termed as late binding. 

// C# program to illustrate the

// concept of late binding

using System;


class GFG {

static void Main()

{

// Dynamic objects

dynamic obj = 4;

dynamic obj1 = 5.678;


// Display the type of objects

Console.WriteLine("The type of the objects are :");


// GetType() method is 

// used to get the type

Console.WriteLine(obj.GetType());

Console.WriteLine(obj1.GetType());

}

}

Output :

The type of the objects are :
System.Int32 
System.Double 




Comments

Post a Comment

Popular posts from this blog

C# | Association, Aggregation and Composition

Image
Association, Aggregation, and Composition are terms that represent relationships among objects. They are very basic stuff of Object-Oriented Programming. Association Association is a relationship among the objects. Association is "*a*" relationship among objects. In Association, the relationship among the objects determines what an object instance can cause another to perform an action on its behalf. We can also say that an association defines the multiplicity among the objects. We can define a one-to-one, one-to-many, many-to-one and many-to-many relationship among objects. Association is a more general term to define a relationship among objects. Association means that an object "uses" another object. For example, Managers and Employees, multiple employees may be associated with a single manager and a single employee may be associated with multiple managers. Aggregation Aggregation is a special type of Association. Aggregation is "*the*" relationship amo...
Read more

Throw vs Throw ex in C#

In C#, the   "throw"   keyword is used to throw an exception when an error occurs in your code. However, there are two variations of the   "throw"   statement:   "throw"   and   "throw ex" . We will look at the distinctions between   "throw"   and   "throw ex"   in C# in this article. In C#, the  "throw"  keyword is used to declare an exception. When an exception is thrown, the code that can handle it uses a catch block to capture it. The  "throw"  keyword is typically used to throw a new exception object, which can be created using the  "new"  keyword. For example, look at the below code: C# Code: try    {        // Some code that could potentially throw an exception    }   catch  (Exception ex)   {        // Handle the exception  ...
Read more

String[] args in C#

String[] args is a parameter of the Main method that represents the command-line arguments passed to the application when it is executed1. For example, if you run your application like this: MyApp.exe arg1 arg2 arg3 The args array will contain three strings: "arg1", "arg2", and "arg3". You can use the args array to access the command-line arguments and perform different actions based on them. For example, you can write a program that copies a file from one location to another by passing the source and destination paths as arguments1. Here is a simple example of how to use String[] args in C#: public   class Program  {       static void Main(string[] args)     {          Console.WriteLine("Number of arguments: " + args.Length);          foreach (string arg in args)         {             Console.WriteLine("Argument: " + arg);       ...
Read more