Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

C# Inheritance Constructor Order

Learn how C# constructor order works with inheritance: base constructors run first, derived constructors run after, including the base keyword and virtual call pitfalls.

~4 min readC#
#C##Inheritance#Constructors#Object Initialization
Diagram showing the order of constructor execution in C# inheritance, with base class constructor running before derived class constructor.

In C#, when you instantiate a derived class, the constructor of the base class runs before the constructor of the derived class. This order is fixed and affects how you design initialization logic. Understanding this order is essential for avoiding subtle bugs in object initialization.

The Execution Order of Constructors in Inheritance

When you create an instance of a derived class in C#, the runtime first executes the constructor of the base class, then the constructor of the derived class. This order is guaranteed by the language specification. Consider this minimal example:

csharp
public class Base { public Base() { Console.WriteLine("Base constructor"); } } public class Derived : Base { public Derived() { Console.WriteLine("Derived constructor"); } }

If you instantiate Derived, the output is:

code
Base constructor Derived constructor

The base constructor runs first because the derived class inherits the base class's state. Before you can initialize fields specific to the derived class, the base portion of the object must already be in a valid state.

What Happens When You Don't Call a Base Constructor Explicitly

If a derived class constructor does not explicitly call a base constructor using base, the compiler implicitly calls the parameterless constructor of the base class. If the base class has no parameterless constructor, you must explicitly call one of its constructors with base. For example:

csharp
public class Base { public Base(string message) { Console.WriteLine(message); } } public class Derived : Base { public Derived() : base("Base initialized") { Console.WriteLine("Derived initialized"); } }

Without the base("Base initialized") call, this code would not compile because the base class lacks a parameterless constructor.

Parameterized Constructors and the base Keyword

The base keyword lets you pass arguments to a base constructor. This is useful when the base class requires initialization data. The base constructor call must appear in the initializer list of the derived constructor, before the constructor body. You can also chain constructors within the same class using this, but that does not affect the inheritance order.

csharp
public class Base { protected int _value; public Base(int value) { _value = value; } } public class Derived : Base { public Derived() : base(42) { // Additional initialization } }

Virtual Calls Inside Constructors: Why They Are Dangerous

When a base constructor calls a virtual method, the runtime dispatches to the most derived override, even though the derived constructor has not yet run. This can lead to unexpected behavior because the derived class's fields are not yet initialized. Consider:

csharp
public class Base { public Base() { Initialize(); } protected virtual void Initialize() { Console.WriteLine("Base Initialize"); } } public class Derived : Base { private string _name = "Derived"; public Derived() { Console.WriteLine("Derived constructor"); } protected override void Initialize() { Console.WriteLine($"Derived Initialize: {_name}"); } }

When you create a Derived instance, the base constructor calls Initialize(), which resolves to Derived.Initialize(). At that point, _name is still null because the derived constructor's field initializer has not run. The output is:

code
Derived Initialize: Derived constructor

This is a common source of bugs. Avoid calling virtual methods from constructors unless you fully understand the initialization order.

Static Constructors and Their Order

Static constructors are different. They run once per type, before any static member is accessed or any instance is created. In an inheritance hierarchy, the static constructor of the base class runs before the static constructor of the derived class, but only when the type is first used. For example:

csharp
public class Base { static Base() { Console.WriteLine("Base static constructor"); } } public class Derived : Base { static Derived() { Console.WriteLine("Derived static constructor"); } }

If you instantiate Derived, the output is:

code
Base static constructor Derived static constructor

Static constructors are not called every time an instance is created; they run once per type in the process.

Practical Implications for Object Initialization

Understanding the constructor order helps you design initialization logic correctly. If you need to set up fields that depend on base class state, do it in the derived constructor after the base constructor has completed. Avoid relying on virtual method calls during construction. Also, be aware that field initializers in the derived class run before the derived constructor body, but after the base constructor. The exact order is:

  1. Base constructor (including its field initializers)
  2. Derived field initializers
  3. Derived constructor body

This means you cannot use derived class fields in a base constructor call, because they are not initialized yet.

Common Mistakes and How to Avoid Them

One common mistake is assuming that the derived constructor runs before the base constructor. That is never the case. Another is calling virtual methods from a base constructor, which can lead to null references or uninitialized state. A third mistake is forgetting to call a base constructor when the base class has no parameterless constructor, resulting in a compile error.

To avoid these issues, keep constructors simple. If you need complex initialization, use a factory method or an initialization method that is called after the object is fully constructed. This gives you more control over the order of operations and avoids the pitfalls of virtual dispatch during construction.

Try matching browser tools

All tools

Small utilities that fit C# work — they run entirely in this browser tab, so nothing you paste leaves your device.

All C# guides

More in C#

All C# guides

The guides filed next to this one in C#, in library order.