Constructors

In the previous lesson you created an Employee like this: new Employee { Name = "Asha", Role = "Engineer" }. Nothing stopped you leaving the name out. Nothing stopped you setting a salary of minus four hundred.

A constructor closes that gap. It is a block of code that runs once, when an object is created, and it is the only moment at which you can be certain nobody else has touched the object yet. That makes it the right place to state the rules a valid object must obey.

public class Employee
{
    public string Name { get; }
    public string Role { get; }
    public decimal AnnualSalary { get; }

    public Employee(string name, string role, decimal annualSalary)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("An employee must have a name.", nameof(name));
        }

        if (annualSalary <= 0m)
        {
            throw new ArgumentOutOfRangeException(nameof(annualSalary), "Salary must be above zero.");
        }

        Name = name;
        Role = role;
        AnnualSalary = annualSalary;
    }
}

Employee asha = new Employee("Asha", "Engineer", 1_200_000m);   // fine
Employee broken = new Employee("", "Engineer", 0m);             // throws immediately

• A constructor has the same name as the class and no return type. That is how the compiler recognises it.
• Each property is declared { get; } with no set. A get-only property can be assigned inside the constructor and nowhere else, so once the object exists its values cannot change.
• The two if blocks are the invariants, written down as code. If either fails, the constructor throws and no object comes back.
• nameof(name) produces the text "name". It tells the caller which argument was wrong, and it keeps working if you later rename the parameter.
• The last line never produces an Employee. There is no partially built object left behind to worry about.

Two details that catch people out. If you write no constructor at all, C# supplies an invisible one that takes no arguments — that is why new Employee { ... } worked before. The moment you declare any constructor of your own, that free one disappears. new Employee() no longer compiles, which is exactly what you want here.

And a constructor is allowed to throw. An exception from a constructor means creation failed, so the caller never receives a reference. There is no half-built object in the wild.

public class Invoice
{
    public string Reference { get; }
    public decimal Amount { get; }
    public DateOnly DueDate { get; }

    // Convenience: most invoices are due in 30 days.
    public Invoice(string reference, decimal amount)
        : this(reference, amount, DateOnly.FromDateTime(DateTime.Today).AddDays(30))
    {
    }

    // The one constructor that actually does the work and the checking.
    public Invoice(string reference, decimal amount, DateOnly dueDate)
    {
        if (string.IsNullOrWhiteSpace(reference))
        {
            throw new ArgumentException("An invoice needs a reference.", nameof(reference));
        }

        if (amount <= 0m)
        {
            throw new ArgumentOutOfRangeException(nameof(amount), "An invoice must be for a positive amount.");
        }

        Reference = reference;
        Amount = amount;
        DueDate = dueDate;
    }
}

• Two constructors with different parameter lists is called overloading. The compiler picks the one that matches the arguments you passed.
• : this(...) after the parameter list means "run that other constructor first, then my body". Here the short constructor fills in a default due date and hands over.
• The important consequence: the validation exists once. Add a third convenience constructor next year and it still cannot skip the checks.
• DateOnly holds a date with no time component, which is the right type for a due date.