What is the Constructor Chaining in C# dotnet

1. Why Use Constructor Chaining?

   • To avoid duplicating initialization code across multiple constructors.
   • To ensure that all constructors follow a consistent initialization process.
   • To make the code more maintainable and easier to read.

2. Chaining Within the Same Class (this) :

   • When you have multiple constructors in a class, you can call one constructor from another using the this keyword.
   • The this keyword must be the first statement in the constructor.

3. Chaining to a Base Class Constructor (base) :

   • If your class inherits from a base class, you can call a constructor of the base class using the base keyword.
   • Like this, the base keyword must also appear as the first statement in the constructor.

using System;

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    // Default constructor
    public Person() : this("Unknown", 0) // Chains to the parameterized constructor
    {
        Console.WriteLine("Default constructor called.");
    }

    // Parameterized constructor
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
        Console.WriteLine($"Parameterized constructor called: Name = {Name}, Age = {Age}");
    }
}

class Employee : Person
{
    public string Department { get; set; }

    // Default constructor
    public Employee() : base("Employee", 25) // Chains to the base class constructor
    {
        Department = "Unknown";
        Console.WriteLine("Employee default constructor called.");
    }

    // Parameterized constructor
    public Employee(string name, int age, string department) : base(name, age) // Chains to the base class

1. Person Class :

   • The Person class has two constructors:
     • A default constructor that chains to the parameterized constructor using this("Unknown", 0).
     • A parameterized constructor that initializes the Name and Age properties.

2. Employee Class :

   • The Employee class inherits from Person and adds a Department property.
   • It has two constructors:
     • A default constructor that chains to the base class's parameterized constructor using base("Employee", 25).
     • A parameterized constructor that chains to the base class's parameterized constructor using base(name, age).

3. Execution Flow :

   • When creating a Person object, the default constructor calls the parameterized constructor, which initializes the properties.
   • When creating an Employee object:
     • The default constructor calls the base class's parameterized constructor and then initializes the Department property.
     • The parameterized constructor calls the base class's parameterized constructor and then initializes the Department property.

Constructor chaining is especially useful in inheritance hierarchies where derived classes need to initialize properties defined in the base class.

https://www.c-sharpcorner.com/article/constructor-chaining2/

Constructor Chaining in C# is a technique where one constructor calls another constructor in the same class or in the base class. This helps avoid code duplication and keeps initialization logic centralized.

Constructor chaining in C# .NET is a technique where one constructor calls another constructor within the same class or a base class. This is primarily used to reduce code duplication and improve code reusability, as common initialization logic can be placed in a single constructor and then called by others.