Advertisement

---

Top

< Prev

Next >

In C#, a constructor is used to create an object of a class by using the new keyword, where an object is also known as an instance of a class. Each object will have its own instance variables and access to the methods of its class.

Some important features of a constructor are -

• A constructor MUST have the same name as the class.
• A constructor CANNOT have a return type.
• A constructor may have any access modifier like private, public, protected.
• A constructor is never inherited or overridden as it's not an instance method.

Different types of constructors in C#



• No-argument constructor.
• Constructor with access modifiers
• Default no-argument constructor(supplied by the compiler).
• Parameterized constructor.
• Overloaded constructor.

No-argument constructor


To create an object of a class, we can create a constructor that accepts no arguments/parameters and because this constructor accepts no argument, such constructor is called a no-argument constructor.

An example of no-argument constructor -

//C# Example of no-argument constructor

using System;

class A
{
//A no-argument constructor of class A
//With public access modifier
public A()		
{
	Console.WriteLine("Constructor of class A is called");
}

public void Message()
{
	Console.WriteLine("A");
}
}

class B
{
public static void Main(String[] ar)
{
	//Calling a no-argument constructor of class A
	A ob= new A();	

	//Calling the method Message() of class A
	//by using its object
	ob.Message();
}
}





Output-




Constructor of class A is called
A


In the code just above, we have created a class A with a no-argument constructor. To create an object of class A, this constructor is called and the message in constructor body is displayed on the console.

Note: The no-argument constructor of class A was defined with public access modifier, which made it possible to be called from class B(outside the scope of class A).






Constructor with private access modifier


A constructor may have access modifier like - public, protected and yes, even private. The rules of access modifiers that apply to instance variables, methods of a class, apply to a constructor as well.

Therefore, just like private instance variables or methods, a constructor marked private is only accessible inside its class and it would be inaccessible outside the scope of its class.



//C# Although we can create a constructor with private access modifier
//But, a private constructor cannot be called outside the scope its class.

using System;

class A
{
private A()
{
	Console.WriteLine("Constructor of A is called");
}
}

class B
{
public static void Main(String[] ar)
{
	//The private constructor of class A is called outside its class, hence, compile error.
	A ob = new A();	
}
}





Output-




A.cs(19,13): error CS0122: 'A.A()' is inaccessible due to its protection level


We have created a class A with a private no-argument constructor, therefore, when this constructor is called in class B(outside the scope of its class), a compile error is issued.




Advertisement






Constructor with protected access modifier


The rules of protected access modifiers that apply to instance variables, methods of a class, apply to a constructor as well.

Therefore, a constructor with protected access modifier can either be directly called from within its class or it can be called from within the subclass of its class, only by inheritance.



//C# Although we can create a constructor with protected access modifier
//But, a protected constructor can only be called from a subclass of its class, by inheritance.

using System;

class A
{
protected A()
{
	Console.WriteLine("Constructor of A is called");
}


}


//class B is inheriting from class A
class B:A
{
public static void Main(String[] ar)
{
	//We cannot directly call the protected constructor of a class with its subclass.
	//A ob = new A();  --> This, if uncommented will issue a compile error

	//The protected constructor of class A is called outside its class, by inheritance
	//Calling a subclass no-argument constructor, automatically calls the superclass no-argument constructor
	B ob = new B();	
}
}





Output-




Constructor of A is called


Calling a subclass's no-argument constructor, automatically calls the superclass's no-argument constructor, therefore, when we have called the constructor of class B, its superclass's no-argument constructor is automatically called.






Default Constructor - Compiler supplied no-argument constructor


C# runtime system i.e. common runtime library(CLR) adds a default no-argument constructor to your class when it is created, only when you don't type any constructor in your class. If in case, you have provided a constructor in your class, then you are not supplied the default no-argument constructor.
• A default constructor is always a no-argument constructor, i.e. it accepts no arguments.
• By default, the access modifier of default no-argument constructor is public.



//C# Calling the default no-argument constructor

using System;

class A
{
//Defining a method Message() of class A
public void Message()
{
	Console.WriteLine("A");
}
}

class B
{
public static void Main(String[] ar)
{
	//Calling the default no-argument constructor of class A, outside its class A
	//Which is fine, because its access modifier is by default, public 
	A ob = new A();	

	//Calling the method Message() 
	//By using the object of class A
	ob.Message();	
}
}





Output-




A


In the last example, class A wasn't provided with any constructor, hence it is given an invisible public default no-argument constructor, which was called in class B(outside its class) to create an object of class A.






Parameterized Constructor


Unlike no-argument constructors that accept no arguments when they are called, a parameterized constructor accepts arguments when it is called to create an object. Using the values passed to it, a parameterized constructor is used to initialize an object with values immediately during its creation.

Note: While making a call to a constructor, the type and the number of the arguments passed to a constructor should match with the signature of a constructor, otherwise a compile error is thrown.

An example of parameterized constructors -

//C# Example of a parameterized constructor 

using System;

class Names
{
//Instance variables
String firstName;
String secondName;

//A parameterized constructor
//with public access modifier
public Names(String firstN, String secondN)
{
	firstName=firstN;
	secondName=secondN;
}

//A method of class Names
public void Comedian()
{		
	Console.WriteLine(firstName + " " + secondName);
}
}



class D
{
public static void Main(String[] ar)
{
	//Calling the parameterized constructor of class Names
	//with two String values to create an object of class Nmaes
	Names ob= new Names("Charlie","Chaplin"); 

	//Calling the method Comedian() of class Names
	ob.Comedian();
}
}





Output-




Charlie Chaplin


In this program, class Names is created with a constructor which accepts two String values, which is called to create an object of its class.






Overloaded Constructors

Overloading a constructor means providing multiple versions of a constructor, where each version has a different type or number of argument list.

Use of overloaded constructors

• Overloaded constructors are mainly used to provide multiple ways to create objects of a class, rather than having a monotonous way to create objects of a class through a single constructor.
• Each of these multiple constructors is involved in some specialized task while creating an object of the class.

An example of overloaded constructor

//C# Example of a class with overloaded constructors i.e. different versions of a constructor 

using System;

class MathOP
{

//Constructor to add two int values
public MathOP(int a, int b)	
{
	Console.WriteLine(a+b);
}

//Constructor to add two String objects
public  MathOP(String a, String b)	
{
	Console.WriteLine(a+b);
}


//Constructor to add two float values
public MathOP(float a, float b)	
{
	Console.WriteLine(a+b);
}


//Constructor to add two char values
public MathOP(char a, char b)
{
	Console.WriteLine((char)(a+b));
}
}


class Cons
{
public static void Main(String[] ar)
{
	//Calling the constructor version which takes two int values
	MathOP ob1= new MathOP(1,2);
	
	//Calling the constructor version which takes two String values
	MathOP ob2= new MathOP("John","Denver");
	
	//Calling the constructor version which takes two float values
	MathOP ob3= new MathOP(2.2f, 2.5f);
	
	//Calling the constructor version which takes two char values
	MathOP ob4= new MathOP('a', 'x');
}
}

Output-

3
JohnDenver
4.7
U

In this program, we have created a class MathOP having multiple versions of constructors, where each version has a different type or number of argument list i.e. each constructor involved in some specialized talk of adding two integers, characters, strings or float values.




How does a compiler know which constructor to call?
Based on the type and the number of arguments used to call a constructor, a specific constructor is called. For example - if a constructor is called with int arguments, a constructor accepting int arguments is invoked and int values are passed to it.

Please share this article -

< Prev

Next >

< C# Inheritance

C# Destructors >

Advertisement