All About Constructor In C#

A constructor is a special type of method of a C# class which invokes automatically when a new instance of a class is created. Constructor is used in object initialization and memory allocation of the class. Constructor is used to initialize private fields and their values of the class. A constructor can be overloaded.

When we don’t create constructor for the class, the compiler automatically create a default constructor for the class. Constructor name is always same of the class name.

General Syntax for Constructor

[Access Modifier] ClassName([Parameters])
{
}

Types of Constructors in C# 

• Default Constructor
• Parameterized Constructor
• Static Constructor
• Private Constructor

 

Default Constructor in C#

A constructor which does not have any parameters or we can say without any parameters is called default constructor. It initializes the same value of every instance of class.

using System;
namespace ConstructorExample
{
    public class Employee
    {
        public string EmployeeName;
        public string EmployeeAddress;
        //Default Constructor
        public Employee()
        {
            EmployeeName = "Mukesh Kumar";
            EmployeeAddress = "New Delhi";
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Employee emp = new Employee();
            Console.WriteLine("Name of Employee :" + emp.EmployeeName);
            Console.WriteLine("Address of Employee :" + emp.EmployeeAddress);
            Console.ReadLine();
        }
    }
}

Parameterized Constructor

A constructor that has at least one parameter is called a Parameterized Constructor. Using this type of constructor, we can initialize each instance of the class with different values.

using System;
namespace ConstructorExample
{
    public class Employee
    {
        public string EmployeeName;
        public string EmployeeAddress;
        //Parameterized Constructor
        public Employee(string name, string address)
        {
            EmployeeName = name;
            EmployeeAddress = address;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Employee emp = new Employee("Mukesh Kumar", "New Delhi");
            Console.WriteLine("Name of Employee :" + emp.EmployeeName);
            Console.WriteLine("Address of Employee :" + emp.EmployeeAddress);
            Console.ReadLine();
        }
    }
}

Static Constructor

A static constructor is used to initialize any type of static data of the class or perform action need to be performed only once. A Static Constructor is called automatically before the first instance of the class or any static data is referenced. It is called only once for any number of classes instance is created.

using System;
namespace ConstructorExample
{
    public class Employee
    {
        public static readonly long Baseline;
        public string EmployeeName;
        public string EmployeeAddress;
        //Static Constructor
        static Employee()
            {
                Baseline = DateTime.Now.Ticks;
                Console.WriteLine("Static constructor executes first");
            }
            //Default Constructor
        public Employee()
        {
            EmployeeName = "Mukesh Kumar";
            EmployeeAddress = "New Delhi";
            Console.WriteLine("Executes after static constructor");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Employee emp = new Employee();
            Console.WriteLine("Name of Employee :" + emp.EmployeeName);
            Console.WriteLine("Address of Employee :" + emp.EmployeeAddress);
            Console.ReadLine();
        }
    }
}

Key point of static constructor

• Only one static constructor can exist in a class.
• It doesn’t take any parameter because of it automatically called by the CLR or access modifier.
• It is called automatically before the first instance of the class created.
• We cannot call static constructors directly.

When to use static constructors

Static constructors are very useful when you create wrapper classes for unmanaged code. You can also use it when class is using log file and constructor is used to write entries.

Private Constructor

A private constructor is a special constructor that generally used in class that contains only static members. If class has only private constructors not any public constructor then it is not possible to create instance of the class. Basically private constructor prevents to create instance of the class. If you want to create instance of the class which has private constructor then you need to create a public constructor along with private constructor.

using System;
namespace ConstructorExample
{
    public class Employee
    {
        private Employee()
        {}
        public static int currentEmployee;
        public static int IncreamentEmployee()
        {
            return ++currentEmployee;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Employee.currentEmployee = 50;
            Console.WriteLine("Current Employee is :" + Employee.currentEmployee);
            Console.WriteLine("Increament Employee is " + Employee.IncreamentEmployee());
            Console.ReadLine();
        }
    };
}

Thanks for reading this article. Hope you enjoyed it.