CodeProject: An Intro to Constructors in C#. Free source code and programming help

Report Article

Discuss

Send to a friend

48 votes for this Article.

Popularity: 5.81 Rating: 3.46 out of 5

Introduction

Broadly speaking, a constructor is a method in the class which gets executed when its object is created. Usually, we put the initialization code in the constructor. Writing a constructor in the class is damn simple, have a look at the following sample:

public class mySampleClass
{
    public mySampleClass()
    {
        // This is the constructor method.

    }
    // rest of the class members goes here.

}

When the object of this class is instantiated, this constructor will be executed. Something like this:

mySampleClass obj = new mySampleClass()
// At this time the code in the constructor will // be executed

Constructor Overloading

C# supports overloading of constructors, that means, we can have constructors with different sets 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.

}

Well, note here that call to the constructor now depends on the way you instantiate the object. For example:

mySampleClass obj = new mySampleClass()
// At this time the code of no parameter  

// constructor (First Constructor)will be executed

 
mySampleClass obj = new mySampleClass(12)
// At this time the code of one parameter  

// constructor(Second Constructor)will be 

// executed.

The call to the constructors is completely governed by the rules of overloading here.

Calling Constructor from another Constructor

You can always make a call to one constructor from within another. Say, for example:

public class mySampleClass
{
    public mySampleClass(): this(10)
    {
        // This is the no parameter constructor method.

        // First Constructor

    }

    public mySampleClass(int Age) 
    {
        // This is the constructor with one parameter.

        // Second Constructor

    }
}

Very first of all, let us see what is this syntax:

public mySampleClass(): this(10)

Here, this refers to same class, so when we say this(10), we actually mean execute the public mySampleClass(int Age) method. The above way of calling the method is called initializer. We can have at the most one initializer in this way in the method.

Another thing which we must know is the execution sequence i.e., which method will be executed when. Here, if I instantiate the object as:

mySampleClass obj = new mySampleClass()

Then the code of public mySampleClass(int Age) will be executed before the code of mySampleClass(). So, practically the definition of the method:

public mySampleClass(): this(10)
{
    // This is the no parameter constructor method.

    // First Constructor

}

is equivalent to:

public mySampleClass()
{
    mySampleClass(10) 
    // This is the no parameter constructor method.

    // First Constructor

}

Note: Above (just above this line) code is mentioned there for pure analogy and will not compile. The intention here is to tell the flow of execution if initializers are used.

We cannot make an explicit call to the constructors in C#, treating them as if any simple method, for example: statement mySampleClass(10) in the above code will not work. The only way you can call one constructor from another is through initializers.

For the VB.NET programmers: you can make the call to another constructor of the same class by the syntax Me.New(param list), but it should be the first line of your calling constructor method. So ultimately, the code of the called constructor runs prior to the code of the calling constructor, which is same as initializers here.

Note that only this and base (we will see it further) keywords are allowed in initializers, other method calls will raise an error.

This is sometimes called Constructor chaining.

Huff… Simple thing made tough, but this is how it is. Anyway, let us proceed further.

Behavior of Constructors in Inheritance

Let us first create the inherited class.

public class myBaseClass
{
    public myBaseClass()
    {
        // Code for First Base class Constructor

    }

    public myBaseClass(int Age)
    {
        // Code for Second Base class Constructor

    }

    // Other class members goes here

}

public class myDerivedClass : myBaseClass
// Note that I am inheriting the class here.

{
    public myDerivedClass()
    {
        // Code for the First myDerivedClass Constructor.

    }

    public myDerivedClass(int Age):base(Age)
    {
        // Code for the Second myDerivedClass Constructor.

    }

    // Other class members goes here

}

Now, what will be the execution sequence here:

If I create the object of the derived class as:

myDerivedClass obj = new myDerivedClass()

Then the sequence of execution will be:

public myBaseClass() method.
and then public myDerivedClass() method.

Note: If we do not provide initializer referring to the base class constructor then it executes the no parameter constructor of the base class.

Note one thing here: we are not making any explicit call to the constructor of base class neither by initializer nor by the base keyword, but it is still executing. This is the normal behavior of the constructor.

If I create an object of the derived class as:

myDerivedClass obj = new myDerivedClass(15)

Then the sequence of execution will be:

public myBaseClass(int Age) method
and then public myDerivedClass(int Age) method

Here, the new keyword base has come into picture. This refers to the base class of the current class. So, here it refers to the myBaseClass. And base(10) refers to the call to myBaseClass(int Age) method.

Also note the usage of Age variable in the syntax: public myDerivedClass(int Age):base(Age). [Understanding it is left to the reader].

Private Constructors

Private constructors, the constructors with the "private" access modifier, are a bit special case. It is because we can neither create the object of the class, nor can we inherit the class with only private constructors. But yes, we can have the set of public constructors along with the private constructors in the class and the public constructors can access the private constructors from within the class through constructor chaining.

Say for example, my class is something like this :

public class myClass
{
    private MyClass()
    {
        Console.WriteLine("This is no parameter Constructor");
    }

    public MyClass(int var):this()
    {
        Console.WriteLine("This is one parameter Constructor");
    }    
    // Other class methods goes here

}

Then we can create the object of this class by the statement:

MyClass obj = new MyClass(10);

The above statement will work fine, but the statement

MyClass obj = new MyClass();

will raise an error : 'Constructors.MyClass.MyClass()' is inaccessible due to its protection level

It is possible to have the class with only the private constructors. But yes as I said, such class can neither be instantiated nor be inherited. If we try to inherit the class with only private constructors then we will get the same error as above. Also recall, once you provide constructor from your side the compiler will not add the no-parameter public constructor to your class.

Well, one of the usage scenarios of such class could be – when you have only static members in the class and you don't need to instantiate it.

Phew… lost… Anything left in constructors? Yes, Static Constructors. Ha!! Now, what are they? Let us see..

Static Constructors

This is a new concept introduced in C#. By new here, I mean that it was not available for the C++ developers. This is a special constructor and gets called before the first object is created of the class. The time of execution cannot be determined, but it is definitely before the first object creation - could be at the time of loading the assembly.

The syntax of writing the static constructors is also damn simple. Here it is:

public class myClass
{
    static myClass()
    {
        // Initialization code goes here.

        // Can only access static members here.

    }
    // Other class methods goes here

}

Notes for Static Constructors:

There can be only one static constructor in the class.
The static constructor should be without parameters.
It can only access the static members of the class.
There should be no access modifier in static constructor definition.

Ok fine, all the above points are fine, but why is it like that? Let us go step by step here.

Firstly, the call to the static method is made by the CLR and not by the object, so we do not need to have the access modifier to it.

Secondly, it is going to be called by CLR, who can pass the parameters to it, if required. So we cannot have parameterized static constructor.

Thirdly, non-static members in the class are specific to the object instance. So static constructor, if allowed to work on non-static members, will reflect the changes in all the object instances, which is impractical. So static constructor can access only static members of the class.

Fourthly, overloading needs the two methods to be different in terms of methods definition, which you cannot do with Static Constructors, so you can have at the most one static constructor in the class.

Now, one question raises here, can we have two constructors as:

public class myClass
{
    static myClass()
    {
        // Initialization code goes here.

        // Can only access static members here.

    }
    public myClass()
    {
        // Code for the First myDerivedClass Constructor.

    }

    // Other class methods goes here

}

This is perfectly valid, though doesn't seem to be in accordance with overloading concepts. But why? Because the time of execution of the two methods are different. One is at the time of loading the assembly and one is at the time of object creation.

Constructors FAQs

Is the constructor mandatory for a class?
Yes, it is mandatory to have the constructor in the class and that too should be accessible for the object i.e., it should have a proper access modifier. Say, for example, we have only private constructor(s) in the class and if we are interested in instantiating the class, i.e., want to create an object of the class, then having only private constructor will not be sufficient and in fact it will raise an error. So, proper access modifies should be provided to the constructors.
What if I do not write the constructor?
In such case, the compiler will try to supply the no parameter constructor for your class, behind the scene. Compiler will attempt this only if you do not write the constructor for the class. If you provide any constructor (with or without parameters), then compiler will not make any such attempt.
What if I have the constructor public myDerivedClass(), but not the public myBaseClass()?
It will raise an error. If either the no parameter constructor is absent or it is in-accessible (say it is private), it will raise an error. You will have to take the precaution here.
Can we access static members from the non-static (normal) constructors?
Yes, we can. There is no such restriction on non-static constructors. But there is one on static constructors that it can access only static members.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Neeraj Saluja

.NET Professional, working with a leading global firm.

Primarily works in ASP.NET 1.1, ASP.NET 2.0, C# with Oracle and MS SQL Server 2000 as backend.

Learning .Net ...

[ My Linked In Profile ^ ][ MicrosoftTalks ^ ]

Occupation:	Web Developer
Location:	United States

Other popular .NET Framework articles:

The 30 Minute Regex Tutorial
Learn how to use regular expressions in 30 minutes with Expresso.
Strings UNDOCUMENTED
Detailed looked at the implementation of strings in .NET
Expresso - A Tool for Building and Testing Regular Expressions
For learning, building, and debugging .NET Framework regular expressions
Unraveling the Mysteries of .NET 2.0 Configuration
Learn how to utilize the powerful new .NET 2.0 configuration features to simplify and centralize your configuration code.
Simple Windows Service Sample
A simple application to show how to create a Windows service.

Article Top

You must Sign In to use this message board.

Msgs 1 to 25 of 25 (Total in Forum: 25) (Refresh)

FirstPrevNext

Subject

Author

Date

Problems when deriving from a control

FriendOfAsherah

22:46 16 Nov '07

I derived a class from a control (System.Windows.Forms.ToolStrip) and added the constructors like

public ModulToolStrip() : ModulToolStrip(null)
{
}

public ModulToolStrip(string name)
{
... some code goes here
}

The problem only arises when opening a Form which contains this Toolstrip in the designer - it shows up an error.
Removing the call ModulToolStrip(null) from the default (no parameter) constructor hides the error.

public ModulToolStrip() : ModulToolStrip(null)
{
}

But code works fine even when the designer shows up the error.

Re: Problems when deriving from a control

Neeraj Saluja

22:14 18 Nov '07

You need to use the keyword "this" for calling another construtor from the same class Or "base" to call another construtor from the base class. So with the details you have posted, I think the syntax for the same should look like :

public ModulToolStrip() : this(null)
{
}

public ModulToolStrip(string name)
{
... some code goes here
}

If this does not help, please post the Excpetion details like
1. Error Message
2. You are seeing at the compile time Or Run Time
etc

Thanks
Neeraj Saluja

Re: Problems when deriving from a control

FriendOfAsherah

22:40 19 Nov '07

Thanks ! This works now in the designer too, ( But I wonder why the old C++ Style call `ClassName(null)` only shows an error in the designer, not in the running code ... )
Sign In·View Thread·PermaLink

Time of static constructor execution [modified]

CAmelinckx

4:26 3 Oct '06

Subtle error on your article, the static constructor doesn't run at the "time of loading the assembly", it is executed right before the first access to any member (static or non-static) of the class, which can be much later or even never if no member of that class is ever accessed.
Sign In·View Thread·PermaLink

default constructor

wurakeem

9:55 17 Aug '06

I don't mean to be preachy but "the no parameter constructor" has an official name: default constructor.
Sign In·View Thread·PermaLink

Re: default constructor

CAmelinckx

4:37 3 Oct '06

Not quite true wurakeem, the "default constructor" is the one that is automatically added by the C# compiler if you don't provide one yourself. If you specify it, it is typically called "parameterless constructor".
Sign In·View Thread·PermaLink	5.00/5 (1 vote)

Re: default constructor

wurakeem

6:36 4 Oct '06

I have to disagree. Unless C# definition is different from C++, default constructor means constructor without parameters.

default constructor is a constructor without any arguments or one with arguments where default values were supplied, which effectively is the same if the user does not pass a parameter on it. What you are talking about is called "implicit default constructor,"
where the language provides the constructor IFF you don't declare any.
REFERENCES:
http://www-numi.fnal.gov/offline_software/srt_public_context/WebDocs/Companion/cxx_crib/constructors.html
look for sentence
"C++ requires that all classes have a default constructor, that is to say a constructor that can be used without arguments."
or
http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.4

Why "implicit" ? - because it only works when you don't declare any constructors yourself and it creates one (without parameters) for you.

1st. example shows default constructor, 2nd. shows implicit default constructor. Try removing the default constructor from 1st example and watch what happens.
using System;
using System.IO;

//1st.
class Car
{
	string x;
	public static void Main(string[] args)
	{

		Car mycar = new Car();
		Car mycar2 = new Car("Ferrari");

	}
	
	public Car()
	{
		x = "Toyota"; 	//default constructor
	}	
	public Car(string name)	//constructor with 1 arg
	{
		x = name;
	}

}
//2nd.
using System;
using System.IO;

class Car
{
	string x;
	public static void Main(string[] args)
	{

		Car mycar = new Car();         //implicit default constructor
	}
}

Re: default constructor

CAmelinckx

8:49 8 Oct '06

The C# specs are somewhat different than C++'s, at least in terminology.

You can get them here:

http://download.microsoft.com/download/a/9/e/a9e229b9-fee5-4c3e-8476-917dee385062/csharp%20language%20specification%20v1.0.doc[^]

For value types we have (Sec.4.1.2):

"All value types implicitly declare a public parameterless instance constructor called the default constructor. The default constructor returns a zero-initialized instance known as the default value for the value type."

For instance constructors we have (Sec.10.10.4):

"If a class contains no instance constructor declarations, a default instance constructor is automatically provided. That default constructor simply invokes the parameterless constructor of the direct base class"

You are correct in that the term "default constructor" is used to identify this type of constructor in the reference. The term "parameterless constructor" is used as well interchangeably. There is no mention of "implicit default constructor".

In C# there is no default constructor "with arguments where default values were supplied", if you supply values, it's explicitly written by the programmer, default means provided by the IL compiler, you can achieve a similar effect by overloading the constructor as in:

class Text
{
public Text(): this(0, 0, null) {}
public Text(int x, int y): this(x, y, null) {}
public Text(int x, int y, string s) {
// Actual constructor implementation
}
}
Smile

Muliple Constructor

miftha

18:26 19 Feb '06

say; if there are multiple constructors in the base class and the derived class.
I want to access two different base class constructors from the derived class using the same set of parameters for the derived class constructor and different parameters for the base class constructor.

Ex: Base class point has x,y points where the values passed from the constructor plus the distance from (0,0),
there is sub class of this called circle and I want to have two constructors which will accept x,y,radius and distance fromm (0,0) and then use two different constructor of the base class to initialize.

how can i do it.

A.Miftha Idroos.

2.00/5 (1 vote)

Re: Muliple Constructor

Neeraj_Saluja

22:06 19 Feb '06

Miftha,

What I could infer from your query is : You have a base class and you want to initialise two sets of values i.e, Points "x & y" and "Radius & Distance". Seems like you are forced to keep them in two seperate constructors.

In such a case what I would suggest is : Create another Constructor which takes four parameters and initialise all the four values in it.
You can do it in two ways :
1. directly by initialising all the four values in it,
2. Create two Private methods, each one to initialise two values. Call them one after the other in your constructor. Call them as per need from other inidividual constructors.

Please note that you cannot have chains to more than one Constructor from one Constructor. One Constructor can pass the chain to only one other Constructor. If you try doing so, It will give you compile time error. So in such case you can put the logic in private methods (may be void) and call them from the constructors.

Well also, since your two (multiple) contructors which you want to call will be having two different set of parameters ( overloading rules ), you can chain one constructor from derived class and pass on the chain to another within the base class internally.

It all depends how you want to design your application.

If you feel that I haven't answered your question, please provide some pseudocode along with some more details, I will surely reply.

Regards,
Neeraj Saluja

Private Constructors...

AlexCode

8:47 24 Jun '05

Hi...
I was reading this article and I just wanted to add/correct what is said about the Private Constructors.

You're right on your example, but you're wrong when you say that we can't create an instance of a class wich have only private constructors.
A very good example is the System.Data.DataRow object... Smile

This is possible using Reflection.
Thru reflection you can do whatever you like, even create an object using a private constructor.

If you really want, in .net, to avoid a class to be instantiated, you must create a private constructor and throw an exception in it...
Only this way it will be impossible to the object to be created.

Alex Poke tongue

Re: Private Constructors...

Neeraj_Saluja

2:57 26 Jul '06

Thanks for bringing this up. This article is meant for initial level person. I beleive bringing the discussion of Reflections would add confusion to them. Thanks, Neeraj Saluja
Sign In·View Thread·PermaLink

Constructors Chaining question

Amos Cividalli

3:22 23 Feb '05

Hello and thanks for this clear article.
I have come across it trying to learn the subject of constructors chaining, and still have an unanswered question:
Is there a way I can call another constructor with some calculated parameters (that cannot fit into one line)? let's say the one overload of the constructor received a user object as a parameter, and another one may receive only name, create a new user object and than call the "regular" constructor. I have noticed that I can write (and run) something similar to the following code:

public mySampleClass(string usr_name): this(new UsrObj(usr_name)) {}

public mySampleClass(UsrObj usr)
{
// This is the actual constructor method.
// Do some code.
}

But what if creating a new UsrObj needs more than one line of code (e.g. updating a DB or saving data somehow)? Can it be done?

1.50/5 (2 votes)

Good article

Paul Watson

1:07 2 Jun '04

Just a thank you for the article. I am doing my best to teach my team OO and this article on constructors has helped. Also taught me a few things regards, Paul Watson Bluegrass South Africa Ian Darling wrote: "and our loonies usually end up doing things like Monty Python." Crikey! ain't life grand?
Sign In·View Thread·PermaLink

Re: Good article

Neeraj_Saluja

19:22 2 Jun '04

Thanks for the compliments. Regards, Neeraj Saluja
Sign In·View Thread·PermaLink

Constructors vs. methods

TRON

22:33 1 Jun '04

A nice article though a common mistake is to think of constructors as methods, but they are not. Methods are able to return a value or object and if they do not one must specify 'void' in the declaration and definition. Constructors cannot return anything.

And from an OO view methods are operations that objects perform on themself or on other objects. They are the interface of an object; they give access to the inner, encapsulted parts of objects. Constructors on the other hand are helpfull to an OO programmer initializing a object when it is created.

Nice Explaination

Wackatronic

14:55 31 May '04

Nice beginner tutorial. Thanks for you, the newbies like myself can start getting a better grasp on C#. Keep on the good work. *I won't dignify your question with an answer.* *Yes, I program in VB6, but only because I'm addicted to eating!*
Sign In·View Thread·PermaLink

Re: Nice Explaination

Neeraj_Saluja

19:08 1 Jun '04

Thanks for the compliments. Regards, Neeraj Saluja
Sign In·View Thread·PermaLink

Private constructors

SpookyKid

3:24 12 May '04

Hi,

You stated that private constructors are of no use - surely they are of significant use as they allow factory methods to control the creation of object.

For example
If we have a class called user which has no public constructor but has static factory methods such as LoadUser or CreateUser which set appropriate internal state information to say its new or it has been loaded from a database, we can then control object instantiation in much cleaner fashion than just allowing the developer to create a new user class and set the state themselves.

A very good example of factory methods being used to control object instantiation/construction is Rocky Lhotka's CSLA.NET which uses this methodology/design pattern.

Regards,

Peter Cook

Re: Private constructors

Neeraj_Saluja

3:46 12 May '04

Hey Peter,

I take your point. I admit, it was a mistake from my side.

I wanted to say if you are interested in instantiating the class i.e., wanna create an object of the class then having only private constructor will be of no use and in fact it will raise an error.

I take your point that when we have static methods in the class and if are not interested in creating the instance of the class then private constructors can play a vital role.

I apologise for this confusion.

Thanks for bringing this thing into notice. I have updated the article.

Regards,
Neeraj Saluja

Is equivalent??

Anonymous

8:39 11 May '04


public mySampleClass(): this(10)
{
    // This is the no parameter constructor method.
    // First Constructor
}

is equivalent to

 
public mySampleClass()
{
     mySampleClass(10) 
     // This is the no parameter constructor method.
     // First Constructor
}

Are you sure?
If they are "equivalent", why complier-developer create redundant method?
For the people who only-know-VB, it may be true. But for rest of people , it may not always be true. Rose

Re: Is equivalent??

neerajsaluja

20:08 11 May '04

The intention here was to discuss the sequence of execution of constructors.

Ok, let us look at the example again, It says :

public mySampleClass(): this(10)
{
// This is the no parameter constructor method.
// First Constructor
}

is equivalent to 

public mySampleClass()
{
mySampleClass(10)
// This is the no parameter constructor method.
// First Constructor
}

Here, what I mean is - if we use initializers to call another constructors of the same class then the execution of constructor called in initializer will be done prior to its own execution. So in case of "public mySampleClass(): this(10)", public mySampleClass(int Age) constructor method will be called prior to the code of "public mySampleClass()" itself.

So here we can say that the execution is as if we are calling the method "public mySampleClass(int Age)" from "public mySampleClass()" and the call to "public mySampleClass(int Age)" method is the first line of code in "public mySampleClass()".

The above snippet was given for analogy purpose only.

Now, I would like to ask you one thing, Can you make a call to constructor treating it as a simple method, do you think that the following code will work :

public mySampleClass()
{
mySampleClass(10) 
// This is the no parameter constructor method.
// First Constructor
}

Will the above code compile ?

Well, I appreciate that you brought up this thing. It will help all of us to have better understanding.

Still if you are not convinced or if we have any concerns/issues, please let me know.

Regards,
Neeraj Saluja

Re: Is equivalent??

Anonymous

8:39 12 May '04

`public mySampleClass() { mySampleClass(10) // This is the no parameter constructor method. // First Constructor }` Will the above code compile ? Why ask me? That's your code, not mine.
Sign In·View Thread·PermaLink	1.00/5 (2 votes)

Re: Is equivalent??

Neeraj_Saluja

19:17 12 May '04