What does Tell, Don't Ask mean, and how does it change the way you design domain classes in C#?

1. Origin and relatives

2. A state machine as the entity

          MarkPaid()          Ship()
Pending ------------> Paid ----------> Shipped
   |                    |
   | Cancel()           | Cancel()
   v                    v
 Cancelled <------------+
(Shipped → Cancel() = failure)

Each transition is a method; illegal transitions are rejected in one place. Tests cover the table of transitions directly.

3. Collections without bypasses

public sealed class Order
{
    private readonly List<OrderLine> _lines = [];
    public IReadOnlyList<OrderLine> Lines => _lines;

    public void AddLine(Sku sku, int quantity, Money unitPrice)
    {
        if (Status != OrderStatus.Pending) throw new InvalidOperationException("Order is locked");
        if (quantity <= 0) throw new ArgumentOutOfRangeException(nameof(quantity));
        _lines.Add(new OrderLine(sku, quantity, unitPrice));
    }
}

EF Core maps _lines via the backing field (builder.Navigation(o => o.Lines).UsePropertyAccessMode(PropertyAccessMode.Field)).

4. Result types vs exceptions

Either way, the decision is made inside the entity.

5. Cross-aggregate decisions

public sealed class TransferService
{
    public Result Transfer(Account from, Account to, Money amount)
    {
        var withdrawn = from.Withdraw(amount);   // tell
        if (!withdrawn.IsSuccess) return withdrawn;
        to.Deposit(amount);                      // tell
        return Result.Ok();
    }
}

The service coordinates; each account still enforces its own rules.

6. Interfaces for behaviour

When several types share a behaviour contract (e.g. ICancellable for orders and subscriptions), an interface lets callers "tell" without knowing the concrete type. Keep it small (ISP) and behaviour-shaped (Cancel()), not state-shaped (Status { get; set; }).

7. Try it yourself

1. Find a service that sets an entity's Status directly.
2. Add an action method on the entity with the rule, and make the setter private.
3. Build and fix every compile error by calling the method; count how many duplicated checks disappear.
4. Write transition tests for the entity (one per allowed/denied transition).
5. Expose a collection as IReadOnlyList<T> with an AddX method and map the backing field in EF Core.

var order = new Order(Guid.NewGuid());
order.MarkPaid();
order.Ship();

var result = order.Cancel();
Console.WriteLine(result.IsSuccess ? "Cancelled" : result.Error); // Shipped orders cannot be cancelled

public enum OrderStatus { Pending, Paid, Shipped, Cancelled }

public readonly record struct Result(bool IsSuccess, string? Error)
{
    public static Result Ok() => new(true, null);
    public static Result Fail(string error) => new(false, error);
}

public sealed class Order(Guid id)
{
    public Guid Id { get; } = id;
    public OrderStatus Status { get; private set; } = OrderStatus.Pending; // no external writes

    public void MarkPaid()
    {
        if (Status != OrderStatus.Pending) throw new InvalidOperationException("Only pending orders can be paid");
        Status = OrderStatus.Paid;
    }

    public void Ship()
    {
        if (Status != OrderStatus.Paid) throw new InvalidOperationException("Only paid orders can ship");
        Status = OrderStatus.Shipped;
    }

    // Tell: the order owns the cancellation rule.
    public Result Cancel()
    {
        if (Status is OrderStatus.Shipped) return Result.Fail("Shipped orders cannot be cancelled");
        if (Status is OrderStatus.Cancelled) return Result.Ok();
        Status = OrderStatus.Cancelled;
        return Result.Ok();
    }
}