How to Call a Base Class Constructor in C#

By the end of this page, you will understand how constructor chaining works in C#, how to call a base class constructor using : base(...), and why this is especially useful when creating custom exception classes and other derived types.

In C#, when you create an object from a derived class, the base part of that object must be initialized too. That means the base class constructor runs as part of object creation.

If the base class needs arguments, you must pass them in the constructor declaration, not from inside the constructor body. C# uses constructor initializer syntax for this:

public Child(string value) : base(value)
{
}

This matters because the base class must be constructed before the derived class constructor body runs. By the time execution enters the { ... } body of your derived constructor, base initialization has already happened.

For your Exception example, the correct approach is:

class MyExceptionClass : Exception
{
    public string ExtraInfo { get; }

    public MyExceptionClass(string message, string extraInfo) : base(message)
    {
        ExtraInfo = extraInfo;
    }
}

This passes message to , while the derived class handles its own additional data.

Think of building a house extension.

• The base class is the original house.
• The derived class is the new extension.
• Before you can finish the extension, the original house must already exist.

So in C#, the base constructor is called first to build the base part of the object. Then the derived constructor finishes the rest.

base(...) is like saying: "First, build the original part using these materials, then I will add my own part."

Core syntax

Use : base(...) after the constructor signature:

public DerivedType(arg1, arg2) : base(baseArg1, baseArg2)
{
    // derived class setup
}

Basic example

using System;

class Person
{
    public string Name { get; }

    public Person(string name)
    {
        Name = name;
    }
}

class Employee : Person
{
    public int EmployeeId { get; }

    public Employee(string name, int employeeId) : base(name)
    {
        EmployeeId = employeeId;
    }
}

Explanation

• Person requires a .

Consider this example:

using System;

class Person
{
    public string Name { get; }

    public Person(string name)
    {
        Console.WriteLine("Person constructor running");
        Name = name;
    }
}

class Employee : Person
{
    public int Id { get; }

    public Employee(string name, int id) : base(name)
    {
        Console.WriteLine("Employee constructor running");
        Id = id;
    }
}

var employee = new Employee("Ava", 42);
Console.WriteLine(employee.Name);
Console.WriteLine(employee.Id);

What happens step by step

1. new Employee("Ava", 42) starts creating an Employee object.
2. C# sees : base(name) in the Employee constructor.

Using base constructors appears in many practical C# scenarios:

Custom exceptions

class ValidationException : Exception
{
    public ValidationException(string message) : base(message)
    {
    }
}

Used when you want standard exception behavior plus your own exception type.

Reusing common initialization

class DbEntity
{
    public Guid Id { get; }

    public DbEntity(Guid id)
    {
        Id = id;
    }
}

class User : DbEntity
{
    public string Email { get; }

    public User(Guid id, string email) : base(id)
    {
        Email = email;
    }
}

Useful when multiple classes share common fields.

UI or framework classes

Some framework base classes need configuration values during construction. Derived classes pass those values upward.

In real projects, developers commonly use base constructor calls in these patterns:

Passing required state upward

If the base class owns a piece of data, let the base class initialize it.

class AppError : Exception
{
    public AppError(string message) : base(message) { }
}

Keeping derived constructors small

Avoid repeating base setup logic in every child class.

class Entity
{
    public DateTime CreatedAt { get; }

    public Entity()
    {
        CreatedAt = DateTime.UtcNow;
    }
}

class Order : Entity
{
    public decimal Total { get; }

    public Order(decimal total) : base()
    {
        Total = total;
    }
}

Validation before storing local values

You can still validate arguments in the derived constructor body, but constructor chaining happens before the body runs. If the validation affects values passed to the base constructor, do it in the argument expression.

1. Trying to call base(...) inside the constructor body

This is the mistake from the original question.

Incorrect

class MyExceptionClass : Exception
{
    public MyExceptionClass(string message)
    {
        base(message); // Invalid
    }
}

Correct

class MyExceptionClass : Exception
{
    public MyExceptionClass(string message) : base(message)
    {
    }
}

2. Forgetting that the base constructor runs first

Beginners sometimes expect derived fields to be available before base(...) runs.

class Base
{
    public Base(string ) { }
}

  : 
{
      _text;

    
    {
        _text = text;
    }
}

class Child : Parent
{
    public Child(string value) : base(value)
    {
    }
}

Rules

• Use : base(...) after the constructor signature.
• The base constructor runs before the derived constructor body.
• You cannot call base(...) like a normal method inside {}.
• If the base class has no parameterless constructor, you must call one of its existing constructors.
• Use this(...) to call another constructor in the same class.

Exception example

class MyExceptionClass : Exception
{
    public MyExceptionClass(string message, string extraInfo) : base(message)
    {
        ExtraInfo = extraInfo;
    }

    public string ExtraInfo { get; }
}

How do you call a base constructor in C#?

Use : base(arguments) after the derived constructor declaration.

public Child(string name) : base(name)
{
}

Can I call base() inside the constructor body?

No. Base constructors must be called using constructor initializer syntax, not as a statement inside the body.

What happens if I do not call a base constructor explicitly?

C# tries to call the parameterless base constructor automatically. If the base class does not have one, you get a compile-time error.

How do I pass a message to Exception from a custom exception?

Use:

public MyExceptionClass(string message) : base(message)
{
}

What is the difference between base(...) and this(...)?

• base(...) calls a constructor in the parent class.

• Inheritance — Base constructor calls are part of how derived classes inherit behavior and state.
• Constructors — You need to understand constructor syntax before using base(...).
• this constructor chaining — Similar idea, but used within the same class instead of the parent class.
• Exception handling — Custom exceptions often rely on calling Exception base constructors correctly.
• Method overriding — Uses base.Member in a related but different way.
• Access modifiers — Constructor visibility affects whether derived classes can call them.
• Object initialization — Base constructor chaining is part of how objects are created in C#.
• Properties — Derived constructors often set additional properties after calling the base constructor.