C# Inheritance & Constructor

Summary: in this tutorial, you’ll learn how C# calls the constructors of the base class and subclass.

The constructor calling order

When you create a new instance of a subclass, C# calls the constructor of the base class first and then the constructor of the subclass. For example:

First, define a Person class with a parameterless constructor:

class Person
{ 
    public Person()
    {
        Console.WriteLine("Called the Person's constructor");
    }
}Code language: C# (cs)

Note that a parameterless constructor of a class is the constructor that has no parameter. If you don’t explicitly specify a parameterless constructor, the C# compiler will automatically generate one for the class.

Second, define an Employee class that inherits from the Person class:

class Employee : Person
{
    public Employee()
    {
        Console.WriteLine("Called the Employee's constructor");
    }

}Code language: C# (cs)

Third, create a new instance of the Employee class:

var employee = new Employee();Code language: C# (cs)

Output:

Called the Person's constructor
Called the Employee's constructorCode language: C# (cs)

As you can see from the output, C# executes the constructor of the Person class first and then the constructor of the Employee class.

In fact, C# always calls the parameterless constructor of the parent class. Consider the following example.

First, add a constructor with the name parameter to both Person and Employee classes:

class Person
{ 
    public Person()
    {
        Console.WriteLine("Called the Person's constructor");
    }

    public Person(string name)
    {
        Console.WriteLine("Called the Person's constructor with a parameter");
    }
}

class Employee : Person
{
    public Employee()
    {
        Console.WriteLine("Called the Employee's constructor");
    }

    public Employee(string name)
    {
        Console.WriteLine("Called the Employee's constructor with a parameter");
    }

}Code language: C# (cs)

Second, create a new instance of the Employee class:

var employee = new Employee("John Doe");Code language: C# (cs)

Output:

Called the Person's constructor
Called the Employee's constructor with a parameterCode language: C# (cs)

In this case, C# executes the parameterless constructor of the Person class (the base class) first and then the constructor with a parameter of the Employee class (the subclass).

If you remove the parameterless constructor of the Person class and/or the Employee class, you’ll get an error. For example:

class Person
{
    public Person(string name)
    {
        Console.WriteLine("Called the Person's constructor with a parameter");
    }
}

class Employee : Person
{
    public Employee(string name)
    {
        Console.WriteLine("Called the Employee's constructor with a parameter");
    }

}Code language: C# (cs)

Error:

There is no argument given that corresponds to the required formal parameter 'name' of 'Person.Person(string)'Code language: C# (cs)

In this example, the Person class doesn’t have a parameterless constructor. When you create a new instance of the Employee class, C# calls a parameterless constructor of the Person class.

However, it cannot find the parameterless constructor in the Person class. Therefore, it issues an error.

Change the calling order using base()

To fix the issue, you can explicitly call a specific constructor of a parent class instead of letting C# call the parameterless constructor.

To do that, you use the base() after the declaration of the subclass’ constructor as follows:

class Person
{
    public Person(string name)
    {
        Console.WriteLine("Called the Person's constructor with a parameter");
    }
}

class Employee : Person
{
    public Employee(string name): base(name)
    {
        Console.WriteLine("Called the Employee's constructor with a parameter");
    }

}Code language: C# (cs)

Now, if you create a new instance of the Employee class:

// Program.cs

var employee = new Employee("John Doe");Code language: C# (cs)

C# will call the constructor of the Person class first and then the constructor of the Employee class:

Called the Person's constructor with a parameter
Called the Employee's constructor with a parameterCode language: C# (cs)

C# inheritance and constructor example

First, define the Person class with a constructor that has three parameters:

// Person.cs
class Person
{
    public string FirstName { get; set; }

    public string LastName { get; set; }

    public byte Age { get; set; }

    public string FullName => $"{FirstName} {LastName}";

    public Person(string firstName, string lastName, byte age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public string Introduce() => $"Hi, I'm {FullName}.";

}Code language: C# (cs)

Second, define the Employee with a constructor that has five parameters:

// Employee.cs
class Employee : Person
{
    public string JobTitle { get; set; }
    public decimal Salary { get; set; }

    public Employee(string firstName, string lastName, byte age, string jobTitle, decimal salary)
        : base(firstName, lastName, age)
    {
        JobTitle = jobTitle;
        Salary = salary;
    }
}Code language: C# (cs)

In this class, the Employee’s constructor calls the Person’s constructor using the base() syntax.

Summary

• In inheritance, C# always calls the parameterless constructor of the parent class unless you use the base() to call the specific constructor of the parent class.