How to Call One Constructor from Another in C#: Simple Solutions

Why This Matters: One Constructor is Good, Two is Better

Have you ever written a class in C# and noticed you have several constructors that do almost the same thing? For example, one takes a name and age, another takes only a name, and a third takes nothing at all. Instead of copying the same code into every constructor, C# offers an elegant solution: calling one constructor from another. This not only saves time — it makes the code cleaner, more understandable, and easier to maintain. Today we'll break down this topic with real examples, as if you just stumbled upon a popular question on Stack Overflow. Let's go!

How Calling a Constructor from Another Constructor Works in C#

In C#, you can call one constructor from another using the keywords this and base. This is called "constructor chaining." Let's break down both options.

1. The this Keyword — Calling a Constructor in the Same Class

When you have multiple constructors in the same class, you can use this to delegate control to one of them. This is especially useful when one constructor is a "generalization" of another.

A simple example: a Person class that stores a name and age. The default constructor sets standard values, while the parameterized constructor allows overriding them.

public class Person\n{\n    public string Name { get; set; }\n    public int Age { get; set; }\n\n    // Default constructor\n    public Person() : this("Guest", 18)\n    {\n        // Nothing to write here — the chain does everything\n    }\n\n    // Parameterized constructor\n    public Person(string name, int age)\n    {\n        Name = name;\n        Age = age;\n    }\n}

The key point in this code is : this("Guest", 18). When you create an object via new Person(), the parameterless constructor is called, but it immediately delegates control to the constructor with two parameters, passing it the values "Guest" and 18. Thus, all initialization logic is in one place.

2. The base Keyword — Calling a Base Class Constructor

If your class inherits from another class, you can call the base class constructor via base. This ensures that the base part of the object is properly initialized.

Example: a base class Animal and a derived class Dog.

public class Animal\n{\n    public string Species { get; set; }\n\n    public Animal(string species)\n    {\n        Species = species;\n    }\n}\n\npublic class Dog : Animal\n{\n    public string Breed { get; set; }\n\n    // Dog constructor calls the Animal constructor\n    public Dog(string breed) : base("Dog")\n    {\n        Breed = breed;\n    }\n}

Here, : base("Dog") tells the compiler: "First execute the base class Animal constructor with the argument 'Dog', then continue with Dog's initialization." Without this, you would get a compilation error because Animal does not have a default constructor.

Real-World Example: A Popular Stack Overflow Question

Imagine you're working on an online store application. You have an Order class that can be created in different ways: with a customer ID, with a full set of data, or with no parameters at all (for testing).

public class Order\n{\n    public int OrderId { get; set; }\n    public int CustomerId { get; set; }\n    public decimal TotalAmount { get; set; }\n    public DateTime CreatedDate { get; set; }\n\n    // Parameterless constructor — for testing\n    public Order() : this(0, 0, 0)\n    {\n    }\n\n    // Constructor with minimal data\n    public Order(int customerId, decimal totalAmount) : this(0, customerId, totalAmount)\n