C# constructor execution order

In C#, when you do

Class(Type param1, Type param2) : base(param1) 

is the constructor of the class executed first, and then the superclass constructor is called or does it call the base constructor first?

The order is:

• Member variables are initialized to default values for all classes in the hierarchy

Then starting with the most derived class:

• Variable initializers are executed for the most-derived type
• Constructor chaining works out which base class constructor is going to be called
• The base class is initialized (recurse all of this :)
• The constructor bodies in the chain in this class are executed (note that there can be more than one if they're chained with Foo() : this(...) etc

Note that in Java, the base class is initialized before variable initializers are run. If you ever port any code, this is an important difference to know about :)

I have a page with more details if you're interested.

It will call the base constructor first. Also keep in mind that if you don't put the :base(param1) after your constructor, the base's empty constructor will be called.

The constructor of the baseclass is called first.

Not sure if this should be a comment/answer but for those who learn by example this fiddle illustrates the order as well: https://dotnetfiddle.net/kETPKP

using System;

// order is approximately
/*
   1) most derived initializers first.
   2) most base constructors first (or top-level in constructor-stack first.)
*/
public class Program
{
	public static void Main()
	{
		var d = new D();
	}
}

public class A
{
	public readonly C ac = new C("A");

	public A()
	{
		Console.WriteLine("A");
	}
	public A(string x) : this()
	{
		Console.WriteLine("A got " + x);
	}
}

public class B : A
{
	public readonly C bc = new C("B");
	
	public B(): base()
	{
		Console.WriteLine("B");
	}
	public B(string x): base(x)
	{
		Console.WriteLine("B got " + x);
	}
}

public class D : B
{
	public readonly C dc = new C("D");
	
	public D(): this("ha")
	{
		Console.WriteLine("D");
	}
	public D(string x) : base(x)
	{
		Console.WriteLine("D got " + x);
	}
}

public class C
{
	public C(string caller)
	{
		Console.WriteLine(caller + "'s C.");
	}
}

Result:

D's C.
B's C.
A's C.
A
A got ha
B got ha
D got ha
D

Coincidentally , this is also a most asked interview question as well and its explained in this youtube video with demonstration.

First thing do not try to memorize the sequence. Think logically in parent child relationship , child builds on the top of the parent . So obviously first Parent instance should be created and then child.

> So first the parent constructor fires and then child constructor.

But hang on there is a twist when it comes to initializers things are different.

> For initializers first child initializers run and then parent initializers.

Below is the diagrammatic representation of the same. So constructor code fires Parent to Child and Initializers fire from Child to Parent.

[Edit: in the time it took me to answer, the question had totally changed].

The answer is that it calls the base first.

[Original answer to the old question below]

Are you asking when you would do the "base" bit of the constructor call?

If so, you would "chain" a call to the constructor base if the class is derived from another class which has this constructor:

  public class CollisionBase
    {
        public CollisionBase(Body body, GameObject entity)
        {
            
        }
    }

    public class TerrainCollision : CollisionBase
    {
        public TerrainCollision(Body body, GameObject entity)
            : base(body, entity)
        {
            
        }
    }

In this example, TerrainCollision derives from CollisionBase. By chaining the constructors in this way, it ensures the specified constructor is called on the base class with the supplied parameters, rather than the default constructor (if there is one on the base)

Your question is a bit unclear but I'm assuming you meant to ask the following

> When to I call the base constructor for my XNA object vs. using the impilict default constructor

The answer to this is highly dependent on both your scenario and the underlying object. Could you clarify a bit wit the following

• What is the scenario
• What is the type of the base object of TerrainCollision?

My best answer though is that in the case where you have parameters that line up with the parameters of the base class`s constructor, you should almost certainly be calling it.

Constructor mechanism is much better as it leaves the application to use constructor chaining and if you were to extend the application it enables through inheritance the ability to make minimal code changes. Jon Skeets Article