Constructors and Destructors in C#

What Are Constructors?

Constructors are a special type of methods that are associated with a class and get automatically invoked when the classes instance (i.e., objects) are created. Like other member functions, i.e., methods, these constructors also contain specific instructions that get executed when the objects are created. It is specifically used to assign values to all or some data members of a class.

Some Special Characteristics of the Constructor:

  • The name of the constructors must have to be the same as that of the name of the class in which will resides.
  • A constructor can never be final, abstract, synchronized and static.
  • You can produce only a single static constructor.
  • Constructor that is static cannot be used a parameterized constructor.
  • Constructors usually don't have a return type; not even void.
  • The number of constructors can be any within a class.
  • Constructors can contain access modifiers along with it.

Types of Constructors in C#

  1. Default Constructor: When constructors do not have parameters, then it is called the default constructor. These types of constructors have all its instance initialized with the same value.
  2. Parameterized Constructor: When any constructor has at least one parameter, then it is called the parameterized constructor.
  3. Copy Constructor: When the constructor is used to create an object just by copying all of its variables from another object, such constructors are called copy constructor. They are used for initializing a new instance from an existing one.
  4. Private Constructor: When a constructor is produced with a private access modifier, it is called Private Constructor. It does not make it possible for other classes to inherit any data from this class.
  5. Static Constructor: When a constructor needs to be invoked only once and when that constructor needs to be invoked at the creation of the first reference, and then those constructors are made static and are called static constructors.

C# Program to Demonstrate Constructor

Example:
using System;
namespace KarlosData
{
    class EmpGkr
    {
        private string month; 
        private int year; 
        public string name, location;
    
        //Default Constructor
        public EmpGkr()
        {
            name = "Alex Len";
            location = "San Francisco";
        }
    
        //Parameterized Constructor
        public EmpGkr(string a, string b)
        {
            name = a;
            location = b;
        }
        
        public EmpGkr(EmpGkr s) 
        { 
            month = s.month; 
            year = s.year; 
        } 
}

class Program
{
    static void Main(string[] args)
    {
        EmpGkr empGkr = new EmpGkr();
        EmpGkr u2 = new EmpGkr(empGkr); 
        Console.WriteLine(empGkr.name);
        Console.WriteLine(empGkr.location);
        Console.WriteLine("\n Press to Exit .... ");
        Console.ReadLine();
    }
}
}
Output:
Alex Len
San Francisco

What Are Destructors?

Destructor is another method that uses the class-name but is preceded with a ~ (tilde) operator/symbol. Destructors are used to de-initialize object, and the memories occupied when constructors are created. You can consider them as the opposite of constructors.

C# Program to Demonstrate Destructor

public class EmpGkr
{
    int start;
    //constructor
    public EmpGkr()
    {
    val = 10;
    }

    //destructor
    ~ EmpGkr()
    {
    val = 0;
    }
}

Scroll Back to Top