How do constructors work in C#? Explain default and parameterised constructors, chaining with this() and base(), the order of initialisation in a class hierarchy, static constructors, primary constructors (C# 12) and required members, and why calling virtual methods from a constructor is dangerous.

1. What the compiler emits

public class Derived : Base
{
    private int _x = 5;
    public Derived() : base(1) { Console.WriteLine("Derived body"); }
}

becomes, in IL, roughly:

Derived::.ctor()
    ldarg.0; ldc.i4.5; stfld _x          // field initialisers FIRST
    ldarg.0; ldc.i4.1; call Base::.ctor   // then base constructor
    ...Derived body...

That's why initialisers run before base constructors. Constructors chaining with this(...) don't repeat initialisers — only the constructor that calls base(...) (explicitly or implicitly) contains them.

2. Static constructor semantics and beforefieldinit

• With an explicit static constructor, the type initialiser runs exactly at first access to a static member or first instance creation.
• Without one (only static field initialisers), the compiler marks the type beforefieldinit, allowing the runtime to run initialisation any time before the first static field access — often eagerly, and enabling the JIT to skip initialisation checks in hot code.
• The runtime takes a lock while running a .cctor; two types whose static constructors depend on each other across threads can deadlock during start-up.

3. Primary constructor capture in detail

public class Counter(int start)
{
    public int Next() => ++start;    // 'start' captured into a hidden mutable field
}

The compiler synthesises a field like <start>P and rewrites uses. Consequences: the parameter is mutable state (no readonly), and analyzers suggest assigning to an explicit readonly field when immutability matters. For DI services this is usually fine.

4. Object initialisers, init and required

new Customer { Email = "a@b" } compiles to: call the constructor, then call set_Email/init_Email. So the object exists in an incomplete state between the constructor and the initialiser assignments — any validation must happen in the constructor or be enforced by required. required is checked by the compiler at the creation site (and by reflection-based creators that honour RequiredMemberAttribute), not at run time in arbitrary code.

5. Constructors and dependency injection

ActivatorUtilities / the DI container picks the constructor with the most parameters it can satisfy (or the one marked [ActivatorUtilitiesConstructor]). Multiple public constructors can create ambiguity errors. Constructors of DI services should be cheap and side-effect free: no I/O, no async work (constructors can't be async), so resolution is fast and failures are clear. Expensive initialisation belongs in hosted services, factories or IAsyncInitializer-style patterns.

6. Exceptions in constructors

If a constructor throws, the object is never returned — but if it allocated unmanaged resources or registered event handlers before throwing, those leak. Acquire resources last, or wrap with try/catch and dispose. A finalizer may still run on the partially constructed object, so finalizers must tolerate uninitialised fields.

7. Struct constructors

Structs can now declare parameterless constructors and field initialisers (C# 10), but default(T) and arrays bypass them. C# 11 auto-defaults unassigned fields. Never rely on a struct constructor having run.

Try it yourself

1. Add Console.WriteLine to field initialisers and constructor bodies in a three-level hierarchy and observe the order.
2. Reproduce the virtual-call-in-constructor NRE and enable CA2214.
3. Write a primary-constructor class, decompile it in SharpLab, and find the captured field.
4. Make a static constructor throw and access the type twice.

// Chaining and validation in one place
public sealed class Money
{
    public Money(decimal amount) : this(amount, "AUD") { }

    public Money(decimal amount, string currency)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(amount);
        ArgumentException.ThrowIfNullOrWhiteSpace(currency);
        Amount = amount;
        Currency = currency;
    }

    public decimal Amount { get; }
    public string Currency { get; }
}

// Base/derived order and the virtual-call trap
public abstract class Gateway
{
    protected Gateway() => Configure();          // BAD: runs override before derived ctor body
    protected abstract void Configure();
}

public sealed class StripeGateway : Gateway
{
    private readonly StripeOptions _options;
    public StripeGateway(StripeOptions options) : base() => _options = options;
    protected override void Configure() => Console.WriteLine(_options.ApiBase); // _options is null here
}

// Primary constructor for DI, captured into a readonly field
public sealed class OrderService(IOrderRepository repo, ILogger<OrderService> logger)
{
    private readonly IOrderRepository _repo = repo;

    public Task<Order?> FindAsync(int id, CancellationToken ct)
    {
        logger.LogDebug("Finding order {Id}", id);   // 'logger' captured (mutable capture)
        return _repo.FindAsync(id, ct);
    }
}

// Static constructor and required members
public sealed class CountryCodes
{
    public static readonly FrozenSet<string> All;
    static CountryCodes() => All = new[] { "AU", "NZ", "NP" }.ToFrozenSet();
}

public sealed class CreateUserRequest
{
    public required string Email { get; init; }
    public string? DisplayName { get; init; }
}

var req = new CreateUserRequest { Email = "[email protected]" };   // omit Email -> CS9035