What is encapsulation, and how do you apply it well in C#? Show the difference between a class that exposes its data and one that protects its invariants.

1. Invariants: the heart of encapsulation

An invariant is a condition that's true after construction and after every public operation. Examples:

• Order.Total == Lines.Sum(l => l.Amount)
• Booking.End > Booking.Start
• "A shipped order can't change its lines"

Encapsulation is the technique that makes invariants enforceable: if only the object's own methods can change its state, and each method preserves the invariants, then the invariants hold for the object's whole life. This is the basis of Bertrand Meyer's Design by Contract (preconditions, postconditions, invariants).

2. Information hiding vs encapsulation

David Parnas's information hiding (1972) is about hiding design decisions likely to change behind a stable interface — e.g. whether the balance is stored or computed. Encapsulation bundles data with the behaviour that operates on it. Good C# design applies both: bundle behaviour with data, and hide representation choices.

3. Getters/setters are not encapsulation

A class with private fields and public get; set; for every field is still exposing its data — just with extra syntax. The test is: can a caller put this object into an invalid state? If yes, it isn't encapsulated. Properties with logic in setters help a little, but validating one field at a time can't enforce rules that span fields (e.g. start/end dates) — that needs methods.

4. Collections are the common leak

public List<OrderLine> Lines { get; } = new();   // getter-only, but callers can Add/Clear

Even IReadOnlyList<T> returning the underlying List<T> can be cast back. Patterns:

• Expose IReadOnlyList<T> via AsReadOnly() (a wrapper), or an ImmutableArray<T> snapshot.
• Provide AddLine, RemoveLine methods enforcing rules.
• EF Core supports backing fields for navigations (builder.Navigation(o => o.Lines).HasField("_lines")), so persistence doesn't require public setters.

5. Encapsulation and frameworks

• EF Core can materialise entities through private constructors and private setters, and use backing fields — no need for public mutability.
• System.Text.Json can deserialise via constructors ([JsonConstructor]) and init properties; but domain entities usually shouldn't be serialised directly anyway (use DTOs).
• Model binding needs settable properties — another reason to bind to DTOs, not entities.

6. Encapsulation at larger scales

The same principle applies to:

• Assemblies/projects: internal types, exposing only a small public surface; InternalsVisibleTo for tests sparingly.
• Modules in a modular monolith: other modules call a public API, never each other's tables.
• Services: a service owns its database; others go through its API (no shared database writes).

In every case, the owner enforces the rules and can change internals freely.

Try it yourself

1. Take an entity in your code with public setters and list every place that sets them; find duplicated or missing rules.
2. Refactor it with private setters and intention-revealing methods, and write unit tests for each invariant.
3. Map it with EF Core using backing fields and a private parameterless constructor.
4. Try casting an exposed IReadOnlyList<T> back to List<T>, then switch to AsReadOnly().

public sealed class LoyaltyAccount
{
    private readonly List<PointsEntry> _history = [];

    public LoyaltyAccount(string memberId)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(memberId);
        MemberId = memberId;
    }

    public string MemberId { get; }
    public int Points { get; private set; }                    // read publicly, change only here
    public IReadOnlyList<PointsEntry> History => _history;     // read-only view

    public void Earn(int points, string reason)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(points);
        Points += points;
        _history.Add(new PointsEntry(points, reason, DateTimeOffset.UtcNow));
    }

    public void Redeem(int points, string reason)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(points);
        if (points > Points)
            throw new InvalidOperationException($"Cannot redeem {points}; only {Points} available.");
        Points -= points;
        _history.Add(new PointsEntry(-points, reason, DateTimeOffset.UtcNow));
    }
}

public sealed record PointsEntry(int Change, string Reason, DateTimeOffset At);

// account.Points = 1_000_000;   // CS0272: setter is private
// account.History.Clear();      // not available on IReadOnlyList<T>