Types of Constructor in .Net

Introduction

a. Constructors do not return a value.

b. Constructors can be overloaded.

c. If a class is defined with static and Non-static constructors then the privilege will be given to the Non-static constructors.

Objective

Using the code

A. Public Constructor: 

using System;
class MyClass
{
// defalut public constructor
public MyClass()
{
System.Console.WriteLine("This is default constructor"); 
}
//public constructor with parameter
public MyClass(int a)
{
System.Console.WriteLine("Value is "+a);
}
}
class MyProgram
{
// start execution here from main method.
static void Main()
{
// initialize the class object
MyClass myclass1 = new MyClass(); // default constructor
MyClass myclass2 = new MyClass(5);
System.Console.ReadLine(); 
}
}

public class Base
{
protected Base() { }
protected static void staticFoo() { }
protected void instanceFoo() { }
}
public class Derived : Base
{
Derived()
: base() // initialize protected constructor through derived constructor
{ }
// start execution here from main method.
void Main()
{
Base b = new Base(); // Compiler Error: Can not access protected member
b.instanceFoo(); // Compiler Error: Can't call a protected instance method on a Base.
Base.staticFoo(); // You call protected static method
Derived d = new Derived();
d.instanceFoo(); // Can call an inherited protected instance method on a Derived
Derived.staticFoo(); // Can access static method of base class. 
}
}

C. Private Constructor : 

public class MyClass
{
private MyClass() { } // Private constructor
public static int iCount;
public static int IncrementCount()
{
return ++iCount;
}
}
class MyTestClass
{
// start execution here from main method.
static void Main()
{
MyClass myclass = new MyClass(); // Compiler Exception: Can't initialize class because of private constructor
MyClass.iCount = 100; // static variable directly accessible and initialized
MyClass.IncrementCount(); // Direct call to static method
System.Console.WriteLine("New value: {0}", MyClass.iCount);
}
}

1. Singletons class can implement interfaces or derive from useful base classes.

2. Singleton class object can be use as a parameter which is not possible for Static class.

3. Singletons can be handled polymorphically without forcing their users to assume that there is only one instance.

class Program
{
static void Main(string[] args)
{
// get the class object without initializing through 'new' keyword
MyClass instance = MyClass.Instance;
}
}
/// <summary>
/// Sealed class. Implemented through Singleton pattern.
/// </summary>
public sealed class MyClass
{
// The internal static valiable of class object
static readonly MyClass _instance = new MyClass();
/// <summary>
/// This is a private constructor, meaning no outsiders have access.
/// </summary>
private MyClass()
{
// initailize the internal variables
}
/// <summary>
/// The Instance object of an MyClass class.
/// Return the _instance object everytime whenever the MyClass class is initialized.
/// </summary>
public static MyClass Instance
{
get { return _instance; }
}
}

class Program
{
static void Main(string[] args)
{
MyClass.foo(); // call the static member directly
MyClass myclass = new MyClass();
myclass.foo(10);
System.Console.ReadLine();
}
}
public class MyClass
{
static int a;
int b;
// Static constructor:
static MyClass()
{
a = 10; // initialize the static variable
//b = 20; // Compile Exception : non-static member can't be access through static constructor
System.Console.WriteLine("I am in static constructor");
}
// non-static constructor
public MyClass()
{
a = 10; // non-static constructor can initialize both static and non-static members
b = 20;
System.Console.WriteLine("I am in non-static constructor");
}
public static void foo()
{
System.Console.WriteLine("I am in static foo");
}
public void foo(int a)
{
System.Console.WriteLine("I am in non-static foo");
}
}

Something More

Constructor Overloading : A constructor with zero arguments is known as the default constructor. A constructor can take zero or more arguments as parameters. The program have multiple constructors in a class with different sets of signatures. Such constructors are known as “overloaded constructors”. The overloaded constructors of a class must differ in their number of arguments, type of arguments, and/or order of arguments. This gives the user the ability to initialize the object in multiple ways.

The class in the program shown below contains three constructors. The first is the default constructor, followed by the two argument constructors. Note that the constructors differ in their signature.

using system;
public class MyClass
{
public MyClass()
{
//Default constructor
}
public MyClass(int sampleValue)
{
// This is the constructor with one parameter. 
}
public MyClass(int firstValue, int secondValue)
{
// This is the constructor with two parameters.
}
}

using system;
public class MyClass
{
public MyClass(): this(10)
{
// This is the default constructor
// calling base class constructor and passing value 10 as parameter
}
public MyClass(int firstValue) 
{
// This is the constructor with one parameter.
}
}

Conclusion

If you like this article, subscribe to our RSS Feed. You can also subscribe via email to our Interview Questions, Codes and Forums section.