Advertisement

---

Top

< Prev

Next >

In C#, a constructor is class member, which is used to create and initialize the objects of a class. Contrary to the working of a constructor, a destructor is a special method and also a class member, which is executed right before an object is de-allocated from the memory by the garbage collector.

A destructor is required in a situation when we want to ensure that the object terminates cleanly by releasing some resources which could be used by the object in question.

A general form of a destructor

Let us show you a general form of a destructor.

~destructor()
{
	//statements in destructor
}

Some important features of a destructor are -

• A destructor must have the same name as its class, preceded by a tilde sign ~
• A destructor cannot have a return type.
• A destructor cannot be defined with arguments i.e. it has no-arguments.
• A destructor is never inherited or overridden, as it's not a general function of a class.

When a destructor is called?

When the garbage collector runs, it frees up the space in memory by finding and deleting those objects on it that are not referenced by any live program i.e. the unreferenced objects, which are no longer in use. At that time, it automatically calls the destructor associated with an object in question, right before the object is taken off the memory.

Note :
• The destructor runs only once in the lifetime of an object, i.e. just before an object is about to be de-allocated from the memory by the garbage collector.





Advertisement






Important point about the garbage collector:


The garbage collector only runs automatically on its own and it won't run just because we have some unreferenced objects in our program, therefore, you cannot be certain about the execution of the garbage collector.

Usually the garbage collection runs after the termination of a program but in some instances, it may only run when it finds the system to be running on a low physical memory or when we have manually called the Collect() method of GC class, which encapsulates garbage-collection facility. For more on garbage collection, please read Garbage collection in C#






An example of a destructor


Let's see an example in which we will create multiple objects of a class by using a constructor, and we will also define a destructor of this class, which will be automatically called right before any of the objects are taken off the memory by the garbage collector.



// C# Example of destructor


using System;

class A
{
//Instance variable of class A
int num;


//Constructor of class A
A(int a)
{
	num = a;
	Console.WriteLine("Creating an object" + num);
}

//Destructor of class A
//This may run at the termination of the program
~A()
{
	Console.WriteLine("Destructing an object" + num);
}


public static void Main(String[] ar)
{

	//A for-loop to create 5 objects of class A
	
	for(int i=0; i<5;i++)
	{
		//Calling the constructor of class A
		//And passing a specific int value
		//That is stored in the instance variable, num, of each object.
		A ob = new A(i);
	}
}
}





Output-




Creating an object0
Creating an object1
Creating an object2
Creating an object3
Creating an object4
Destructing an object4
Destructing an object0
Destructing an object3
Destructing an object2
Destructing an object1





Program Analysis



• In this code above, we have created a class A with a constructor and a destructor.
• Next, we have created 5 objects of this class, by calling the constructor (once for each object), and passing a specific int value, which is stored in the instance variable, num, of each object.
• Finally, upon the termination of the program, the garbage collector runs, and calls the destructor of the class, before it takes the unreferenced object off the Heap memory.


Note: Although in this example, we have only created 5 objects but usually, the garbage collector is activated when you are creating and destroying a large number of objects.






Please share this article -







< Prev
Next >
< C# Constructors
C# Method Overloading >



Advertisement