Encapsulation

Encapsulation is often taught as "make your fields private". That is a mechanism, not the point, and taken alone it produces classes full of private fields wrapped in public setters that guard nothing.

The actual idea: an object should only be changeable in ways that leave it correct. You decide which changes are legitimate, you expose one method for each of them, and you close every other route in. Callers then cannot create a broken object even by accident, because the language will not let them.

public class LeakyOrder
{
    public string Reference { get; set; } = "";
    public List<OrderLine> Lines { get; set; } = new List<OrderLine>();
    public decimal Total { get; set; }
    public bool IsSubmitted { get; set; }
}

LeakyOrder order = new LeakyOrder { Reference = "SO-4471" };

order.Total = 5000m;              // a total with no lines behind it
order.IsSubmitted = true;         // submitted with nothing in it
order.Lines = null!;              // no lines at all, and the type said there would be
order.Reference = "";             // an order nobody can look up

• Every one of those four lines compiles and runs. None of them is a bug in LeakyOrder; the bug is that LeakyOrder has no opinion about anything.
• Total is the clearest failure. It is stored separately from the lines, so the two can disagree, and nothing in the type keeps them in step.
• The rules still exist — an order does need lines before submission. They now live in the heads of whoever writes the calling code, and are enforced by nobody.

The cost of that design shows up later, and not where you would expect. A support ticket says an order was submitted with a total of zero. You search for the code that submitted it and find eleven places that set IsSubmitted. Each is slightly different. One forgot to recalculate the total.

Encapsulation is what reduces eleven suspects to one.

public enum OrderStatus { Draft, Submitted, Cancelled }

public class Order
{
    private readonly List<OrderLine> _lines = new List<OrderLine>();

    public string Reference { get; }
    public OrderStatus Status { get; private set; }

    // A read-only view of the real list. Callers can look; they cannot add.
    public IReadOnlyList<OrderLine> Lines => _lines;

    // Derived, never stored, so it cannot drift away from the lines.
    public decimal Total
    {
        get
        {
            decimal total = 0m;

            foreach (OrderLine line in _lines)
            {
                total += line.LineTotal;
            }

            return total;
        }
    }

    public Order(string reference)
    {
        if (string.IsNullOrWhiteSpace(reference))
        {
            throw new ArgumentException("An order needs a reference.", nameof(reference));
        }

        Reference = reference;
        Status = OrderStatus.Draft;
    }

    public void AddLine(OrderLine line)
    {
        if (Status != OrderStatus.Draft)
        {
            throw new InvalidOperationException("Lines can only be added while an order is a draft.");
        }

        _lines.Add(line);
    }

    public void Submit()
    {
        if (_lines.Count == 0)
        {
            throw new InvalidOperationException("An order needs at least one line before it can be submitted.");
        }

        Status = OrderStatus.Submitted;
    }
}

• OrderStatus is an enum: a type whose value must be one of a fixed set of named options. It rules out the misspelled status strings that a plain string would allow.
• _lines is private and readonly. Private means outside code cannot reach it; readonly means Order itself cannot swap it for a different list, so it is never null.
• Lines exposes IReadOnlyList<OrderLine>. This is a view onto the same list, not a copy — a caller sees additions made through AddLine but has no Add method of their own.
• Total is computed from the lines on every read. The total that disagreed with the lines is now not merely unlikely; it is unrepresentable.
• Status has a private setter, so the only paths to Submitted run through Submit(), where the rule lives. One suspect instead of eleven.