Understanding C# Constructors and it's type

What are constructors: A constructor is a special kind of method that has the same name as it's class and that gets executed when it's (class) object is created.

In other words a constructor is a class default method that gets automatically executed whenever a class's object is created or whenever the class is initialized.

Consider this example

public class demo
{
public demo ()
{
//A default Constructor
}
kjkjhjkhjhjkh
//Class members

}

In this example, the method demo() is called the constructor of the class demo; also called the default constructor.

How it works: whenever you try to create an object of a class or initialize a class, then the default constructor will automatically be invoked.

//Initializes the Class
demo object = new demo();

Point to remember about constructor

1. A constructor can't be inherited, although a derived class can class the base class constructor.
2. You have to explicitly write a default constructor (see below) while overloading constructors.
3. Concept declaring multiple constructors of a class with different sets of parameters known as constructor overloading.
4. A constructor can call another constructor of the same class using this().

 Types of Constructor:

1. Default constructor: A constructor that takes no parameters is called a default constructor. Default constructors are invoked whenever an object is instantiated by using the new operator and no arguments are provided to new.
    
2. Parameterized constructor: when we initialize class members during instantiation we can use a parameterized constructor which is similar to a default constructor except with parameters.

The following is a code example:

public class demo
{
    public demo()
    {
        //A default Constructor
    }

    public demo(String Name)
    {
        //A parameterized Constructor having one parameter|
    }

    public demo(String FirstName, String LastName)
    {
        //A parameterized Constructor having two parameters
    }

    //Class members

}

When you create a parameterized constructor, we need to also declare a default constructor explicitly.

Access modifier for constructor

1. Public constructor: Constructors are public by default.
    
2. Private constructor: It is a special instance constructor. It is commonly used in classes that contain static members only. If a class has one or more private constructors and no public constructors, then other classes (except nested classes) are not allowed to create instances of this class.
   
   public class demo
   {
       private demo()
       {
           //A default Constructor as private
       }
   }
   
   So when we will try to create an object of this class, it will generate an error.
   
   I.e. demo object = new demo () //Error
   
   Is there any way to create an object of this class.
   We can instantiate the class above by declaring another public constructor that has parameters.
   
   public class demo
   {
   private demo()
   {
   //A default Constructor as private
   }
   public demo(String strName): this()
   {
   System.Console.WriteLine("Hello Mr. : " + strName);
   }

   //Class members
   }
   
   And now you can initialize an object of this class:
   
   demo object = new demo() , which will work fine.
    

3. Static Constructor: A static constructor is used to initialize any static data, or to perform an action that needs to be performed only once. It is called automatically before the first instance is created or any static members are referenced.
   
   public class demo
   {
       static demo()
       {
           //A static Constructor
           // Can only access static members here.

           System.Console.WriteLine("I am a static constructor.");
       }
   }
   
   So when we create an object of this class, "I am a static constructor" gets printed.
   
   Examine the code below as well:
   
   public class demo
   {
       static demo()
       {
           //A static Constructor
           // Can only access static members here.

           System.Console.WriteLine("I am a static constructor.");
       }

       public demo()
       {
           //A default Constructor
       }

       //Class members

   }

This example also prints the same result, "I am a static constructor".

Point to remember about static constructor:

1. A static constructor should not be declared with any access modifier.
2. A static constructor does not accept parameters.
3. A static constructor is called automatically.
4. There is no way to call a static constructor directly.

How to call parent class constructor in derived class during inheritance

Answer: It can be achieved by using base().

Example:

class Program
{
public class parent
{
public parent ()
{
//A default Constructor
}

public parent (String strName)
{
//A parameterized Constructor having one parameter
}

//Class members

}

public class child : parent
{
public child ()
{
//A default Constructor
}

public child (String strName) : base(strName)
{
//A parameterized Constructor having one parameter
}

//Class members

static void Main()
{
child object1 = new child (); //1*
child object2 = new child ("Vishal Nayan"); //2*
}

}

Sequence is important here in which constructor is called

1. First parent class public constructor, parent() is called then child class public constructor, child()
2. First parent (String strName) and then child (String strName).