How constructor chaining works in C Sharp (C#) - Practice Exercises

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of constructor chaining with base and this

What is the output of this C# program that uses constructor chaining with this and base?

C Sharp (C#)

using System;
class BaseClass {
    public BaseClass() {
        Console.WriteLine("BaseClass default constructor");
    }
    public BaseClass(string msg) {
        Console.WriteLine("BaseClass says: " + msg);
    }
}
class DerivedClass : BaseClass {
    public DerivedClass() : this("Hello") {
        Console.WriteLine("DerivedClass default constructor");
    }
    public DerivedClass(string msg) : base(msg) {
        Console.WriteLine("DerivedClass says: " + msg);
    }
}
class Program {
    static void Main() {
        var obj = new DerivedClass();
    }
}

A

BaseClass default constructor
DerivedClass says: Hello
DerivedClass default constructor

B

BaseClass says: Hello
DerivedClass says: Hello
DerivedClass default constructor

C

BaseClass says: Hello
DerivedClass default constructor
DerivedClass says: Hello

D

BaseClass default constructor
DerivedClass default constructor
DerivedClass says: Hello

💡 Hint

Remember that this calls another constructor in the same class before executing the body, and base calls the base class constructor.

The DerivedClass() constructor calls this("Hello"), which calls DerivedClass(string msg). That constructor calls base(msg), which prints "BaseClass says: Hello". Then it prints "DerivedClass says: Hello". After returning, the DerivedClass() constructor prints "DerivedClass default constructor".

❓ Predict Output

intermediate

Constructor chaining order in inheritance

What will be printed when this C# program runs?

C Sharp (C#)

using System;
class A {
    public A() {
        Console.WriteLine("A()");
    }
    public A(int x) {
        Console.WriteLine("A(int)");
    }
}
class B : A {
    public B() : base(5) {
        Console.WriteLine("B()");
    }
    public B(int x) : this() {
        Console.WriteLine("B(int)");
    }
}
class Program {
    static void Main() {
        var b = new B(10);
    }
}

A

A(int)
B()
B(int)

B

A()
B()
B(int)

C

A(int)
B(int)
B()

D

A()
B(int)
B()

💡 Hint

Check which constructors call which and in what order base constructors run.

The B(int x) constructor calls this(), so B() runs first. B() calls base(5), so A(int) runs first. Then B() prints, then B(int) prints.

🔧 Debug

advanced

Identify the error in constructor chaining

What error will this C# code produce when compiled?

C Sharp (C#)

class Test {
    public Test() : this(5) {
    }
    public Test(int x) : this() {
    }
}

A No error, compiles and runs fine

B Compile-time error: Missing base constructor call

C Compile-time error: Constructor chaining causes a cycle

D Runtime error: Stack overflow

💡 Hint

Check if constructors call each other in a loop.

The Test() constructor calls this(5), and Test(int x) calls this(). This creates an infinite loop of constructor calls, which is detected at compile time as a cycle.

❓ Predict Output

advanced

Output with multiple constructor chaining levels

What is the output of this C# program?

C Sharp (C#)

using System;
class X {
    public X() {
        Console.WriteLine("X()");
    }
    public X(string s) : this() {
        Console.WriteLine("X(string): " + s);
    }
}
class Y : X {
    public Y() : base("hello") {
        Console.WriteLine("Y()");
    }
    public Y(int n) : this() {
        Console.WriteLine("Y(int): " + n);
    }
}
class Program {
    static void Main() {
        var y = new Y(10);
    }
}

A

X()
X(string): hello
Y()
Y(int): 10

B

X(string): hello
X()
Y()
Y(int): 10

C

X()
Y()
X(string): hello
Y(int): 10

D

X()
Y(int): 10
X(string): hello
Y()

💡 Hint

Follow the constructor calls from Y(int) down to base.

Y(int) calls this(), so Y() runs first. Y() calls base("hello"), so X(string) runs, which calls X() first. So order is X(), X(string), Y(), Y(int).

🧠 Conceptual

expert

Why constructor chaining is useful

Which of the following best explains why constructor chaining is useful in C#?

A It prevents any constructor from calling base class constructors explicitly.

B It allows multiple constructors to run in parallel threads for faster object creation.

C It automatically generates default values for all fields without writing code.

D It avoids code duplication by letting one constructor reuse another's initialization logic.

💡 Hint

Think about how constructors can share code.

Constructor chaining lets one constructor call another, so common initialization code is written once and reused. This reduces duplication and errors.