Constructors are class methods that are executed when an object of a class or struct is created. They have the same name as the class or struct, and usually initialize the data members of the new object.
A class or struct may have multiple constructors that take different arguments. Constructors enable the programmer to set default values, limit instantiation, and write code that is flexible and easy to read.
If you do not provide a constructor for your object, C# will create one by default that instantiates the object and sets member variables to the default values as listed in Default Values Table (C# Reference). Static classes and structs can also have constructors.
Constructor Overloading :
C# supports overloading of constructors, that means we can have constructors with different set of parameters. So our class can be like this :
public class mySampleClass
{
public mySampleClass()
{
// This is the no parameter constructor method.
// First Constructor
}
public mySampleClass(int Age)
{
// This is the constructor with one parameter.
// Second Constructor
}
public mySampleClass(int Age, string Name)
{
// This is the constructor with two parameters.
// Third Constructor
}
// rest of the class members goes here.
}
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(basic of parameters):
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(Basic of Access Modifier)
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: An Imp. Things Regards calling Sequence of constructors
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).
copy constructor.(does Not Support in C# )
C# does not provide a copy constructor. If you create a new object and want to copy the values from an existing object, you have to write the appropriate method yourself. For example:
