CONSTRUCTORS IN C#

Constructors have the same name as the class, and usually initialize the data members of the new object.

Constructors allow the programmer to set default values, limit instantiation, and write code that is flexible and easy to read.

A constructor that takes no parameters is called a default constructor. Default constructors are invoked whenever an object is instantiated using the new operator and no arguments are provided to new.

If a class is not defined with the constructor then the CLR (Common Language Runtime) will provide an implicit constructor which is called as Default Constructor.

A class can have any number of constructors provided they vary with the number of arguments that are passed, which is they should have different signatures.

• Constructors do not return a value.
• Constructors can be overloaded.
• If a class is defined with static and Non-static constructors then the privilege will be given to the Non-static constructors.

The following are the access modifiers for constructors,

1) Public : A constructor that is defined as public will be called whenever a class is instantiated.

2) Protected : A constructor is defined as protected in such cases where the base class will initialize on its own whenever derived types of it are created.

3) Private : A constructor is defined as private in such cases whenever a class which contains only static members has to be accessed will avoid the creation of the object for the class.

4) Internal : An internal constructor can be used to limit concrete implementations of the abstract class to the assembly defining the class. A class containing an internal constructor cannot be instantiated outside of the assembly.

5) External : When a constructor is declared using an external modifier, the constructor is said to be an external constructor.

Types of Constructors

1) Static : Used for initializing only the static members of the class. These will be invoked for the very first time the class is being loaded on the memory. They cannot accept any arguments. Static Constructors cannot have any access modifiers.

Static ClassName()
{
//Initialization statements;
}
2) Non-Static : Used for initializing the Non-Static and Static members of a class. These will be invoked everytime a new object is defined for a class.
Public ClassName([arguments])
{
//Initialization statements;
}
 
A Very Clear Example:
Base Class:
using System;
using System.Collections.Generic;
using System.Text;
namespace Constructor1
{
public class BaseClass
{
public BaseClass()
{
Console.WriteLine("Base Class Constructor without parameter");
}
public BaseClass(int Age)
{
Console.WriteLine("Base Class Constructor with parameter {0}",Age);
}
}
}
Derived Class:
using System;
using System.Collections.Generic;
using System.Text;
namespace Constructor1
{
public class DerivedClass:BaseClass
{
public DerivedClass()
{
Console.WriteLine("Derived Class Constructor without parameter");
}
public DerivedClass(int Age): base(Age)
{
int sal = Age * 5;
Console.WriteLine("Derived Class Constructor with parameter {0}, Calculated SAL {1}",Age, sal);
Console.ReadLine();
}
}
}
Program Class:
using System;
using System.Collections.Generic;
using System.Text;
namespace Constructor1
{
class Program
{
static void Main(string[] args)
{
BaseMachi bm = new BaseMachi();
DerivedClass dm = new DerivedClass();
BaseMachi bm1 = new BaseMachi(10);
DerivedClass dm1 = new DerivedClass(10);
}
}

See the output of this program. You'll come to a final conclusion about the Constructors in C#. 

Happy Programming......