Impara Constructor Chaining | Constructors and Overloading

Constructor chaining in C# is a technique that allows you to call one constructor from another within the same class, using the : this() syntax. This is especially useful when you have multiple constructors with overlapping logic, as it helps you avoid repeating the same code in each constructor. By chaining constructors, you can centralize shared initialization code, making your classes easier to maintain and less error-prone.

Laptop.cs


              12345678910111213141516171819202122232425262728293031323334353637383940414243
            
using System;

namespace ConsoleApp
{
    public class Laptop
    {
        public string Brand { get; set; }
        public string Model { get; set; }
        public int RamGB { get; set; }

        // Constructor 1: Default constructor
        public Laptop() : this("Unknown", "Unknown", 4)
        {
            // No additional code needed here
        }

        // Constructor 2: Brand and Model specified, default RAM
        public Laptop(string brand, string model) : this(brand, model, 4)
        {
            // No additional code needed here
        }

        // Constructor 3: All properties specified
        public Laptop(string brand, string model, int ramGB)
        {
            Brand = brand;
            Model = model;
            RamGB = ramGB;
        }

        public static void Main(string[] args)
        {
            Laptop defaultLaptop = new Laptop();
            Laptop midLaptop = new Laptop("Dell", "Inspiron");
            Laptop customLaptop = new Laptop("Apple", "MacBook Pro", 16);

            Console.WriteLine($"Default: {defaultLaptop.Brand}, {defaultLaptop.Model}, {defaultLaptop.RamGB}GB RAM");
            Console.WriteLine($"Mid: {midLaptop.Brand}, {midLaptop.Model}, {midLaptop.RamGB}GB RAM");
            Console.WriteLine($"Custom: {customLaptop.Brand}, {customLaptop.Model}, {customLaptop.RamGB}GB RAM");
        }
    }
}

In the Laptop class above, you can see three constructors. The default constructor calls another constructor using : this("Unknown", "Unknown", 4), which sets default values for all properties. The second constructor allows you to specify the brand and model, but still uses a default RAM value, and it chains to the third constructor with : this(brand, model, 4). The third constructor is the most detailed, accepting all three parameters and performing the actual assignments. This pattern ensures that all initialization logic is kept in a single place, reducing code duplication and making future changes easier—if you need to change the way the properties are set, you only have to update one constructor.

Employee.cs


              123456789101112131415161718192021222324252627
            
// This is a non-runnable example showing constructor chaining with multiple scenarios.

public class Employee
{
    public string Name { get; set; }
    public int Id { get; set; }
    public string Department { get; set; }

    // Constructor 1: Only name
    public Employee(string name) : this(name, 0, "Unassigned")
    {
    }

    // Constructor 2: Name and Id
    public Employee(string name, int id) : this(name, id, "Unassigned")
    {
    }

    // Constructor 3: Name, Id, and Department
    public Employee(string name, int id, string department)
    {
        Name = name;
        Id = id;
        Department = department;
    }
}

When using constructor chaining, always try to keep the most detailed constructor as the one that does the actual property assignments. Less-detailed constructors should chain to more-detailed ones, passing along default values as needed. This helps you avoid duplicating logic and makes your code easier to update. Be careful not to create circular chains, which will result in a compilation error. Also, use constructor chaining only when it simplifies your code—do not overuse it in situations where it might make the logic harder to follow.

Note

Constructor chaining is the process of calling one constructor from another within the same class using the : this() syntax.
It reduces code duplication, centralizes initialization logic, and makes classes easier to maintain and extend.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 5

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you show me an example of constructor chaining in C#?

What are some common mistakes to avoid with constructor chaining?

When should I avoid using constructor chaining?

Scorri per mostrare il menu