How constructor chaining works in C Sharp (C#) - Visual Walkthrough

Concept Flow - How constructor chaining works

Call constructor A

↓

Constructor A calls Constructor B

↓

Constructor B executes

↓

Return to Constructor A

↓

Constructor A completes

↓

Object fully constructed

Constructor chaining means one constructor calls another to reuse code, running the called constructor first before finishing the caller.

Execution Sample

C Sharp (C#)

class Person {
  public string Name;
  public int Age;

  public Person() : this("Unknown", 0) {}
  public Person(string name, int age) {
    Name = name; Age = age;
  }
}

This code shows a default constructor calling another constructor with parameters to set default values.

Execution Table

Step	Constructor Called	Parameters	Action	State Change
1	Person()	none	Calls Person(string, int) with ("Unknown", 0)	No state change yet
2	Person(string, int)	("Unknown", 0)	Sets Name = "Unknown", Age = 0	Name="Unknown", Age=0
3	Person()	none	Returns after Person(string, int) completes	Name="Unknown", Age=0
4	Person()	none	Constructor completes, object created	Final state: Name="Unknown", Age=0

💡 Constructor chaining ends after the called constructor finishes and control returns to the caller.

Variable Tracker

Variable	Start	After Step 2	After Step 4
Name	null	"Unknown"	"Unknown"
Age	0	0	0

Key Moments - 2 Insights

Why does the parameterized constructor run before the default constructor finishes?

Because constructor chaining calls the other constructor first (see execution_table step 1 and 2), so the called constructor sets values before the caller continues.

What happens if the chained constructor is missing?

The code will not compile because the chaining call (': this(...)') requires the target constructor to exist, as shown in the code sample.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of Name after step 2?

A "Unknown"

B null

C "" (empty string)

D 0

💡 Hint

Check the 'State Change' column at step 2 in execution_table.

At which step does the Person(string, int) constructor complete?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Constructor Called' and 'Action' columns in execution_table.

If the default constructor did not chain to the parameterized one, what would happen?

A The program would crash at runtime.

B The parameterized constructor would run anyway.

C Name and Age would remain uninitialized (null and 0).

D The object would have random values.

💡 Hint

Refer to the code sample and understand that without chaining, default constructor sets nothing.

Concept Snapshot

Constructor chaining in C# lets one constructor call another using ': this(...)'.
The called constructor runs first, setting up values.
This avoids repeating code in multiple constructors.
If chaining is missing, each constructor runs independently.
Use chaining to keep initialization consistent and simple.

Full Transcript

Constructor chaining means one constructor calls another constructor in the same class to reuse code. When you create an object, the called constructor runs first, setting up initial values, then control returns to the original constructor to finish. For example, a default constructor can call a parameterized constructor with default values. This way, you avoid repeating code. If the chained constructor does not exist, the code will not compile. Without chaining, constructors run independently and may leave variables uninitialized. This process ensures consistent object setup and cleaner code.

Practice

1. What does constructor chaining in C# allow you to do?

easy

A. Override a constructor in a derived class

B. Call a method from a constructor

C. Create multiple instances of a class at once

D. Call one constructor from another constructor in the same class

Solution

1. Step 1: Understand constructor chaining concept

   Constructor chaining means one constructor calls another constructor within the same class to reuse code.

2. Step 2: Identify what constructor chaining does

   It helps avoid repeating initialization code by calling another constructor using : this(...) syntax.

3. Final Answer:

   Call one constructor from another constructor in the same class -> Option D

4. Quick Check:

   Constructor chaining = calling another constructor [OK]

Hint: Constructor chaining calls another constructor in the same class [OK]

Common Mistakes:

• Confusing constructor chaining with method calls
• Thinking it creates multiple objects
• Mixing it up with inheritance or overriding

2. Which of the following is the correct syntax to chain constructors in C#?

easy

A. public MyClass() : base() { }

B. public MyClass() : this() { }

C. public MyClass() : this(5) { }

D. public MyClass() { this(); }

Solution

1. Step 1: Recall constructor chaining syntax

   Constructor chaining uses : this(parameters) after the constructor signature to call another constructor in the same class.

2. Step 2: Analyze options

   public MyClass() : this(5) { } uses : this(5) which correctly calls another constructor with an int parameter. public MyClass() : this() { } calls itself recursively causing error. public MyClass() : base() { } calls base class constructor, not chaining. public MyClass() { this(); } tries to call constructor inside body, which is invalid.

3. Final Answer:

   public MyClass() : this(5) { } -> Option C

4. Quick Check:

   Constructor chaining syntax = : this(...) [OK]

Hint: Use ': this(...)' after constructor signature to chain [OK]

Common Mistakes:

• Using 'this()' inside constructor body instead of after signature
• Confusing base() with this()
• Calling the same constructor recursively

3. What will be the output of this C# code?

class Test {
  public Test() : this(10) {
    Console.WriteLine("Default constructor");
  }
  public Test(int x) {
    Console.WriteLine($"Constructor with {x}");
  }
}

class Program {
  static void Main() {
    Test t = new Test();
  }
}

medium

A. Constructor with 10
Default constructor

B. Constructor with 10

C. Default constructor
Constructor with 10

D. Default constructor

Solution

1. Step 1: Understand constructor chaining call order

   The parameterless constructor calls this(10), so the constructor with int parameter runs first.

2. Step 2: Trace output order

   First, "Constructor with 10" is printed from the int constructor. Then control returns to parameterless constructor which prints "Default constructor".

3. Final Answer:

   Constructor with 10 Default constructor -> Option A

4. Quick Check:

   Chained constructor runs first, then caller prints [OK]

Hint: Chained constructor runs before the calling constructor body [OK]

Common Mistakes:

• Assuming calling constructor runs first
• Ignoring constructor chaining order
• Mixing output order

4. Identify the error in this constructor chaining code:

class Sample {
  public Sample() : this() {
    Console.WriteLine("Hello");
  }
}

medium

A. Missing base keyword for chaining

B. Recursive constructor call causing infinite loop

C. Constructor chaining syntax is correct

D. Constructor must have a return type

Solution

1. Step 1: Analyze constructor chaining call

   The constructor calls itself with : this(), causing infinite recursion.

2. Step 2: Identify error type

   This recursive call leads to a runtime stack overflow error because no termination occurs.

3. Final Answer:

   Recursive constructor call causing infinite loop -> Option B

4. Quick Check:

   Constructor calling itself = infinite recursion [OK]

Hint: Avoid chaining a constructor to itself directly [OK]

Common Mistakes:

• Thinking chaining to self is allowed
• Confusing base() and this() calls
• Expecting constructor to have return type

5. Given this class, what will be the output when creating new Box()?

class Box {
  public int Width, Height;
  public Box() : this(5, 10) {
    Console.WriteLine("Default Box");
  }
  public Box(int w, int h) {
    Width = w;
    Height = h;
    Console.WriteLine($"Box: {Width}x{Height}");
  }
}

hard

A. Box: 5x10
Default Box

B. Default Box
Box: 5x10

C. Box: 0x0
Default Box

D. Default Box

Solution

1. Step 1: Understand constructor chaining and initialization

   The parameterless constructor calls this(5, 10), so the two-parameter constructor runs first, setting Width and Height and printing their values.

2. Step 2: Trace output order

   First, "Box: 5x10" is printed from the two-parameter constructor. Then control returns to the parameterless constructor which prints "Default Box".

3. Final Answer:

   Box: 5x10 Default Box -> Option A

4. Quick Check:

   Chained constructor runs first, then caller prints [OK]

Hint: Chained constructor runs before caller's body executes [OK]

Common Mistakes:

• Assuming default values 0 for Width and Height
• Thinking default constructor runs first
• Ignoring chaining call order