How to Call One Constructor from Another in C#

By the end of this page, you will understand constructor chaining in C#, how to use this(...) to call one constructor from another, and why this is especially useful when initializing readonly fields without duplicating code.

In C#, a class can have multiple constructors. This is called constructor overloading. Often, several constructors perform similar setup work, which can lead to duplicated code.

To avoid that duplication, C# supports constructor chaining. This means one constructor can call another constructor in the same class by using this(...).

For your example, one constructor already knows how to fully initialize the object:

public Sample(int theInt) => _intField = theInt;

The string-based constructor does not need to assign the field itself. It can first convert the string to an int, then pass that value to the other constructor:

public Sample(string theIntAsString) : this(int.Parse(theIntAsString))
{
}

This matters because:

• It keeps initialization logic in one place.
• It works correctly with readonly fields.
• It makes classes easier to maintain.
• It reduces bugs caused by forgetting to update all constructors.

A readonly field can be assigned:

Think of constructors like different entrances to the same building.

• One entrance accepts an int directly.
• Another entrance accepts a string, but first converts it into an int.

Instead of building two separate check-in desks, you create one main check-in desk. The string entrance simply forwards visitors to the int entrance after converting the value.

So:

• Sample(int) = the main entrance that performs the real setup
• Sample(string) = a convenience entrance that prepares the value and forwards it

This way, all important setup happens in one place.

Core Syntax

To call another constructor in the same class, use : this(...) after the constructor signature.

public ClassName(argumentType value) : this(otherValue)
{
}

Your Example Using Constructor Chaining

public class Sample
{
    private readonly int _intField;

    public Sample(int theInt)
    {
        _intField = theInt;
    }

    public Sample(string theIntAsString) : this(int.Parse(theIntAsString))
    {
    }

    public int IntProperty => _intField;
}

What this does

• Sample(int) performs the actual field assignment.
• Sample(string) parses the string and forwards the result.

Consider this code:

var sample = new Sample("42");
Console.WriteLine(sample.IntProperty);

With this class:

public class Sample
{
    private readonly int _intField;

    public Sample(int theInt)
    {
        _intField = theInt;
    }

    public Sample(string theIntAsString) : this(int.Parse(theIntAsString))
    {
    }

    public int IntProperty => _intField;
}

Step by step

1. new Sample("42") is called.
2. C# selects the constructor that accepts a string.
3. Before that constructor body runs, the : this(int.Parse(theIntAsString)) part executes.
4. int.Parse("42") returns 42.

Constructor chaining is common whenever a class can be created in multiple ways but should still follow one central initialization path.

Common scenarios

• Parsing input
  • Create an object from a string, but store the parsed numeric or date value.
• Default values
  • A shorter constructor fills in default configuration values.
• Convenience overloads
  • Let callers pass fewer arguments while routing to a fuller constructor.
• Validation
  • Convert or validate input first, then delegate to the main constructor.
• Configuration objects
  • Support both simple and advanced object creation patterns.

Example: API client configuration

public class ApiClient
{
    private readonly string _baseUrl;
    private readonly int _timeoutSeconds;

    public ApiClient(string baseUrl, int timeoutSeconds)
    {
        _baseUrl = baseUrl;
        _timeoutSeconds = timeoutSeconds;
    }

    public ApiClient( baseUrl) : ()
    {
    }
}

In real projects, developers usually pick one primary constructor overload that does the actual assignment and validation, then make other constructors delegate to it.

Common patterns

1. Convenience overloads

public ReportGenerator(string outputPath) : this(outputPath, false)
{
}

This avoids repeating assignments.

2. Input normalization before delegation

public Product(string priceText) : this(decimal.Parse(priceText))
{
}

The string-based constructor converts data into the real internal type.

3. Guard clauses in the main constructor

public class Person
{
    private readonly string _name;

    public Person(string name)
    {
         (.IsNullOrWhiteSpace(name))
              ArgumentException(, (name));

        _name = name;
    }

    
    {
    }
}

1. Duplicating initialization logic

Problem

public class Sample
{
    private readonly int _intField;

    public Sample(int theInt)
    {
        _intField = theInt;
    }

    public Sample(string theIntAsString)
    {
        int i = int.Parse(theIntAsString);
        _intField = i;
    }
}

This works, but the assignment logic is repeated.

Better

public Sample(string theIntAsString) : this(int.Parse(theIntAsString))
{
}

2. Trying to call another constructor like a method

Broken code

public Sample(string theIntAsString)
{
    Sample(.Parse(theIntAsString));
}

this(...) vs helper method

Quick syntax

public MyClass(string text) : this(int.Parse(text))
{
}

Rules

• Use : this(...) to call another constructor in the same class.
• The chained constructor call appears in the constructor declaration, not in the body.
• One constructor should usually be the main constructor.
• Other constructors should prepare values and delegate to it.
• This is a good pattern for initializing readonly fields.

Example

public class Sample
{
    private readonly int _intField;

    public Sample(int theInt)
    {
        _intField = theInt;
    }

    public Sample(string text) : this(int.Parse(text))
    {
    }
}

Common pitfalls

How do you call one constructor from another in C#?

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

public Sample(string text) : this(int.Parse(text))
{
}

Can readonly fields be assigned through constructor chaining?

Yes. If the field is assigned in the constructor that gets called through this(...), it is still considered valid constructor-time initialization.

Should every constructor assign fields directly?

Not usually. A common pattern is to have one main constructor do the assignments, while other constructors delegate to it.

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

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

Can I call a constructor from inside another constructor body?

No. In C#, constructor chaining must be declared with : this(...) or : base(...).

• Constructor overloading — Multiple constructors with different parameter lists are the foundation for chaining.
• Readonly fields — Constructor chaining is often used to initialize readonly fields cleanly.
• this keyword — this(...) is one specific use of this in C#.
• Base class constructors — Related because base(...) uses the same constructor-initializer syntax.
• Method overloading — Similar idea of multiple signatures, but for methods instead of constructors.
• Input validation — Constructors often validate data before storing it.
• Exception handling — Parsing and validation in constructors may throw exceptions that should be understood.
• Object initialization — Constructor chaining is one of the main patterns for setting up objects correctly.