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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to call the default constructor from the parameterized constructor.

C Sharp (C#)

public class Car {
    public Car() {
        Console.WriteLine("Default constructor called");
    }

    public Car(string model) : [1] {
        Console.WriteLine($"Car model: {model}");
    }
}

Drag options to blanks, or click blank then click option'

Athis()

Bbase()

CCar()

Dsuper()

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'base()' instead of 'this()' to call the same class constructor.

Trying to call constructor like a method without 'this()'.

In C#, this() calls another constructor in the same class, enabling constructor chaining.

2fill in blank

medium

Complete the code to chain constructors so the parameterless constructor calls the parameterized one.

C Sharp (C#)

public class Book {
    public Book(string title) {
        Console.WriteLine($"Title: {title}");
    }

    public Book() : [1] {
        Console.WriteLine("No title provided");
    }
}

Drag options to blanks, or click blank then click option'

Athis("Unknown")

Bbase()

CBook()

Dthis()

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'base()' which calls the base class constructor instead.

Calling 'this()' without arguments when the parameterized constructor needs one.

The parameterless constructor calls the parameterized one with a default value using this("Unknown").

3fill in blank

hard

Fix the error in constructor chaining by completing the code.

C Sharp (C#)

public class Person {
    public Person(string name) {
        Console.WriteLine($"Name: {name}");
    }

    public Person() : [1] {
        Console.WriteLine("No name given");
    }
}

Drag options to blanks, or click blank then click option'

Athis()

BPerson()

Cbase()

Dthis(null)

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'this()' without arguments when the constructor needs one.

Using 'base()' which calls the base class constructor instead.

The parameterless constructor must call the parameterized one with a string argument, so this(null) is correct.

4fill in blank

hard

Fill both blanks to chain constructors correctly and print the age.

C Sharp (C#)

public class Animal {
    public Animal(string species, int age) {
        Console.WriteLine($"Species: {species}, Age: {age}");
    }

    public Animal(string species) : [1] {
        Console.WriteLine($"Species only: {species}");
    }

    public Animal() : [2] {
        Console.WriteLine("No details provided");
    }
}

Drag options to blanks, or click blank then click option'

Athis(species, 0)

Bthis()

Cthis("Unknown", 0)

Dbase()

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'base()' instead of 'this()' for chaining.

Not passing the required arguments in constructor chaining.

The constructor with one parameter calls the two-parameter constructor with age 0 using this(species, 0). The parameterless constructor calls the two-parameter constructor with "Unknown" and age 0 using this("Unknown", 0).

5fill in blank

hard

Fill all three blanks to chain constructors and initialize all fields.

C Sharp (C#)

public class Employee {
    public string Name;
    public int Id;
    public string Department;

    public Employee(string name, int id, string department) {
        Name = name;
        Id = id;
        Department = department;
        Console.WriteLine($"Name: {Name}, Id: {Id}, Department: {Department}");
    }

    public Employee(string name, int id) : [1] {
        Console.WriteLine("Department set to General");
    }

    public Employee(string name) : [2] {
        Console.WriteLine("Id set to 0 and Department to General");
    }

    public Employee() : [3] {
        Console.WriteLine("Default employee created");
    }
}

Drag options to blanks, or click blank then click option'

Athis(name, id, "General")

Bthis(name, 0, "General")

Cthis("Unknown", 0, "General")

Dbase()

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'base()' instead of 'this()' for chaining.

Not providing all required arguments in chained constructors.

Each constructor calls the three-parameter constructor with default values to chain initialization properly: the two-parameter constructor calls the three-parameter one with "General" department using this(name, id, "General"), the one-parameter constructor calls the three-parameter one with id 0 and "General" using this(name, 0, "General"), and the parameterless constructor calls the three-parameter one with "Unknown", 0, and "General" using this("Unknown", 0, "General").

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