Constructor
is a special method of a class which will invoke automatically whenever
instance or object of class is created. Constructors are responsible for object
initialization and memory allocation of its class. If we create any class
without constructor, the compiler will automatically create one default
constructor for that class. There is always at least one constructor in every
class.
Here
you need to remember that a class can have any number of constructors and
constructors don’t have any return type, not even void and within a class we
can create only one static constructor.
Generally
constructor name should be same as class name. If we want to create constructor
in a class we need to create a constructor method name same as class name check
below sample method for constructor
|
class SampleA
{
public SampleA()
{
Console.WriteLine("Sample A Test Method");
}
}
|
Types
of Constructors
Basically
constructors are 5 types those are
1.
Default
Constructor
2.
Parameterized
Constructor
3.
Copy
Constructor
4.
Static
Constructor
5.
Private
Constructor
Default
Constructor
A
constructor without having any parameters called default constructor. In this
constructor every instance of the class will be initialized without any
parameter values like as shown below
|
using System;
namespace
ConsoleApplication3
{
class Sample
{
public string param1, param2;
public
Sample() // Default
Constructor
{
param1 = "Welcome";
param2 = "Dotnet - world";
}
}
class Program
{
static void Main(string[] args)
{
Sample obj=new Sample();
// Once object of class created automatically
constructor will be called
Console.WriteLine(obj.param1);
Console.WriteLine(obj.param2);
Console.ReadLine();
}
}
}
|
When
we run above program it will show output like as shown below
Output
|
Welcome
Dotnet
- world
|
Parameterized
Constructors
A
constructor with at least one parameter is called as parameterized constructor.
In parameterized constructor we can initialize each instance of the class to
different values like as shown below
|
using System;
namespace
ConsoleApplication3
{
class Sample
{
public string param1, param2;
public Sample(string x, string
y) // Declaring
Parameterized constructor with Parameters
{
param1 = x;
param2 = y;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj=new Sample("Welcome","Dotnet
- world"); // Parameterized
Constructor Called
Console.WriteLine(obj.param1
+" to "+ obj.param2);
Console.ReadLine();
}
}
}
|
When
we run above program it will show output like as shown below
Output
|
Welcome
to Dotnet - world
|
Constructor
Overloading
In
c# we can overload constructor by creating another constructor with same method
name and different parameters like as shown below
|
using System;
namespace
ConsoleApplication3
{
class Sample
{
public string param1, param2;
public
Sample() // Default
Constructor
{
param1 = "Hi";
param2 = "I am Default
Constructor";
}
public Sample(string x, string
y) // Declaring
Parameterized constructor with Parameters
{
param1 = x;
param2 = y;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj =
new Sample();
// Default Constructor will Called
Sample obj1=new Sample("Welcome","Dotnet
- world"); // Parameterized
Constructor will Called
Console.WriteLine(obj.param1
+ ", "+obj.param2);
Console.WriteLine(obj1.param1
+" to " + obj1.param2);
Console.ReadLine();
}
}
|
When
we run above program it will show output like as shown below
Output
|
Hi,
I am Default Constructor
Welcome
to Dotnet - world
|
Copy
Constructor
A
parameterized constructor that contains a parameter of same class type is
called as copy constructor. Main purpose of copy constructor is to initialize
new instance to the values of an existing instance. Check below example for
this
|
using System;
namespace
ConsoleApplication3
{
class Sample
{
public string param1, param2;
public Sample(string x, string y)
{
param1 = x;
param2 = y;
}
public Sample(Sample obj) // Copy Constructor
{
param1 = obj.param1;
param2 = obj.param2;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj =
new Sample("Welcome", "Dotnet
- world"); // Create instance to
class Sample
Sample obj1=new Sample(obj);
// Here obj details will copied to obj1
Console.WriteLine(obj1.param1
+" to " + obj1.param2);
Console.ReadLine();
}
}
}
|
When
we run above program it will show output like as shown below
Output
|
Welcome
to Dotnet - world
|
Static
Constructor
When
we declared constructor as static it will be invoked only once for any number
of instances of the class and it’s during the creation of first instance of the
class or the first reference to a static member in the class. Static
constructor is used to initialize static fields of the class and to write the
code that needs to be executed only once.
|
using System;
namespace
ConsoleApplication3
{
class Sample
{
public string param1, param2;
static Sample()
{
Console.WriteLine("Static Constructor");
}
public Sample()
{
param1 = "Sample";
param2 = "Instance
Constructor";
}
}
class Program
{
static void Main(string[] args)
{
// Here Both Static and instance constructors
are invoked for first instance
Sample obj=new Sample();
Console.WriteLine(obj.param1
+ " " + obj.param2);
// Here only instance constructor will be
invoked
Sample obj1
= new Sample();
Console.WriteLine(obj1.param1
+" " + obj1.param2);
Console.ReadLine();
}
}
}
|
When
we run above program we will get output like as shown below
Output
|
Static
Constructor
Sample
Instance Constructor
Sample
Instance Constructor
|
Importance
points of static constructor
- Static constructor
will not accept any parameters because it is automatically called by CLR.
- Static constructor
will not have any access modifiers.
- Static constructor
will execute automatically whenever we create first instance of class
- Only
one static constructor will allowed.
Private
Constructor
Private
constructor is a special instance constructor used in a class that contains
static member only. If a class has one or more private constructor and no
public constructor then other classes is not allowed to create instance of this
class this mean we can neither create the object of the class nor it can be
inherit by other class. The main purpose of creating private constructor is
used to restrict the class from being instantiated when it contains every
member as static.
|
using System;
namespace
ConsoleApplication3
{
public class Sample
{
public string param1, param2;
public Sample(string a,string b)
{
param1 = a;
param2 = b;
}
private Sample() // Private Constructor Declaration
{
Console.WriteLine("Private Constructor with no prameters");
}
}
class Program
{
static void Main(string[] args)
{
// Here we don't have chance to create instace
for private constructor
Sample obj =
new Sample("Welcome","to
Dotnet - world");
Console.WriteLine(obj.param1
+" " + obj.param2);
Console.ReadLine();
}
}
}
|
Output
|
Welcome
to Dotnet - world
|
In
above method we can create object of class with parameters will work fine. If
create object of class without parameters it will not allow us create.
|
// it will works fine
Sample obj =
new Sample("Welcome","to
Dotnet - world");
// it will not work because of inaccessability
Sample obj=new Sample();
|
Important
points of private constructor
- One use of private
construct is when we have only static member.
- Once we provide a
constructor that is either private or public or any, the compiler will not
allow us to add public constructor without parameters to the class.
- If we want to create
object of class even if we have private constructors then we need to have
public constructor along with private constructor
