What are destructors in C# and why these are used?

Answer 1

What is Destructor
A destructor in C# overrides System.Object.Finalize method.

When should I manually create a destructor?

Almost never. Typically one only creates a destructor when your class is holding on to some expensive unmanaged resource that must be cleaned up when the object goes away. It is better to use the disposable pattern to ensure that the resource is cleaned up. A destructor is then essentially an assurance that if the consumer of your object forgets to dispose it, the resource still gets cleaned up eventually.

If you make a destructor be extremely careful and understand how the garbage collector works. Destructors are really weird:

• They don't run on your thread; they run on their own thread. Don't cause deadlocks!
• An unhandled exception thrown from a destructor is bad news. It's on its own thread; who is going to catch it?
• A destructor may be called on an object after the constructor starts but before the constructor finishes. A properly written destructor will not rely on invariants established in the constructor.
• A destructor can "resurrect" an object, making a dead object alive again. That's really weird. Don't do it.
• A destructor might never run; you can't rely on the object ever being scheduled for finalization. It probably will be, but that's not a guarantee.
• Almost nothing that is normally true is true in a destructor. Be really, really careful. Writing a correct destructor is very difficult.

When have you needed to create a destructor?

When testing the part of the compiler that handles destructors. I've never needed to do so in production code. I seldom write objects that manipulate unmanaged resources.

Answer 2

Destructor

To create destructor we need to create method in a class with same name as class preceded with ~ operator.
Syntax of Destructor

class SampleA
{
public SampleA()
{
// Constructor
}
~SampleA()
{
// Destructor
}
}

Example of Destructor

In below example I created a class with one constructor and one destructor. An instance of class is created within a main function. As the instance is created within the function, it will be local to the function and its life time will be expired immediately after execution of the function was completed.

using System;
namespace ConsoleApplication3
{
class SampleA
{
// Constructor
public SampleA()
{
Console.WriteLine("An  Instance  Created");
}
// Destructor
~SampleA()
{
Console.WriteLine("An  Instance  Destroyed");
}
}

class Program
{
public static void Test()
{
SampleA T = new SampleA(); // Created instance of class
}
static void Main(string[] args)
{
Test();
GC.Collect();
Console.ReadLine();
}
}
}

When we run above program it will show output like as shown below

Output

An instance created
An instance destroyed