Constructor chaining precedence

Question

Say I have this class:

class FooBar
{
    public FooBar() : this(0x666f6f, 0x626172)
    {
    }

    public FooBar(int foo, int bar)
    {
        ...
    }
 ...
}

If I did this:

FooBar foobar = new FooBar();

would the non-parameterized constructor execute first, then the parameterized one, or is it the other way around?

To all those voting to close this question as an exact duplicate of [C# constructor execution order](http://stackoverflow.com/questions/1882692/c-sharp-constructor-execution-order): It is not. The linked question asks about the `base` keyword; this questions asks about the `this` keyword. — Douglas, Jun 02 '12 at 20:43

score 4 · Accepted Answer · answered Jun 02 '12 at 20:40

MSDN has a similar example with base:

public class Manager : Employee
{
    public Manager(int annualSalary)
        : base(annualSalary)
    {
        //Add further instructions here.
    }
}

And states:

In this example, the constructor for the base class is called before the block for the constructor is executed.

Nevertheless, to be sure here's my test:

class Program
{
    public Program() : this(0)
    {
        Console.WriteLine("first");
    }

    public Program(int i)
    {
        Console.WriteLine("second");
    }

    static void Main(string[] args)
    {
        Program p = new Program();
    }
}

Prints

second
first

so the parameterized constructor executes before the explicitly invoked one.

To your last code example: Of course, even _before_ `"second"` is printed the `base()` constructor runs, that is the zero-parameter instance constructor of the base class, `System.Object`. — Jeppe Stig Nielsen, Apr 15 '13 at 18:46

score 3 · Answer 2 · answered Jun 02 '12 at 20:37

3

The control will reach the default constructor first. As we have a call to the parameterized constructor from there, execution of the statements in the default constructor will halted and the control will move to the parameterized constructor. Once the execution of statements in parameterized constructor is completed, the control will move back to the default constructor.

You may verify it by placing a break point at the default constructor.

answered Jun 02 '12 at 20:37

S. Ravi Kiran

4,053
3
21
26

3

Class variables are initialized at first, then chained constructor and then code between braces of default constructor. – Ruben Jun 02 '12 at 20:41

score 1 · Answer 3 · answered Jun 02 '12 at 20:38

1

Don't know if that is documented as "defined behavior", but TestClass(int) executes first and then TestClass().

answered Jun 02 '12 at 20:38

Ruben

2,488
1
18
22

Kamran · Answer 4 · 2018-11-21T19:43:20.390

The order by which constructors are called has nothing to do with constructors being default or non-default (parametrized), but rather it is determined by chaining relation.

In detail, every constructor which is followed by a this keyword, is halted and program jumps to the constructor pointed to by this keyword. When the last chained constructor is reached, its code is run. Then the program runs the previous constructor in the chain and this will go all the way back to the first one.

An example would clarify this.

Suppose inside a class you have 3 constructors as below:

public class Test
{
    // ctor #1
    public Test() : this(5) // this jumps to the ctor #2
    {
        Console.WriteLine("no params");
    }

    // ctor #2
    public Test(int i) : this("Hi") // this jumps to the ctor #3
    {
        Console.WriteLine("integer=" + i.ToString());
    }

    // ctor #3
    public Test(string str) // this ctor will be run first
    {
        Console.WriteLine("string=" + str);
    }
}

If you call the default constructor with var t = new Test(), you will see the following output:

// string=Hi    -> ctor #3
// integer=5    -> ctor #2
// no params    -> ctor #1

Constructor chaining precedence

4 Answers4