Expression-Bodied Members

When a member's whole body is one expression, the braces and the return keyword carry no information. C# lets you replace them with =>, which is read aloud as "goes to".

This is not a new capability. public decimal DueAmount => Total - AmountPaid; compiles to exactly the same thing as a get block with a return statement in it. The only question is which version a reader understands faster, and the answer is not always the shorter one.

public class Invoice
{
    private readonly List<InvoiceLine> _lines = new List<InvoiceLine>();

    public string Reference { get; }
    public DateOnly IssuedOn { get; }
    public decimal AmountPaid { get; private set; }

    public Invoice(string reference, DateOnly issuedOn)
    {
        Reference = reference;
        IssuedOn = issuedOn;
    }

    // One expression each. Nothing is hidden and nothing is computed twice.
    public IReadOnlyList<InvoiceLine> Lines => _lines;
    public bool IsEmpty => _lines.Count == 0;
    public DateOnly DueDate => IssuedOn.AddDays(30);
    public bool IsOverdue => DueDate < DateOnly.FromDateTime(DateTime.Today) && AmountPaid < Total;

    public bool WasIssuedBefore(DateOnly date) => IssuedOn < date;

    public override string ToString() => $"{Reference} issued {IssuedOn:yyyy-MM-dd}";
}

• A property written with => is get-only. There is no setter, so nobody can assign to it, and the expression runs on every read.
• Lines => _lines; exposes the private list as a read-only view. The arrow form makes it clear at a glance that nothing else is going on.
• IsOverdue combines two comparisons, which is still one expression and still one idea: "past the due date and not fully paid".
• A method takes the same form. WasIssuedBefore is one comparison, and a block would add three lines saying nothing.
• ToString is the member most worth converting. The block version of a one-line ToString is four lines of punctuation around one line of content.
• One member of this class is missing here: Total. It is the interesting case, and it appears in the next example.

// Block form, because there is more than one idea here.
public decimal Total
{
    get
    {
        decimal total = 0m;

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

        return total;
    }
}

public void RecordPayment(decimal amount)
{
    if (amount <= 0m)
    {
        throw new ArgumentOutOfRangeException(nameof(amount), "A payment must be positive.");
    }

    if (AmountPaid + amount > Total)
    {
        throw new InvalidOperationException($"Payment exceeds the balance on {Reference}.");
    }

    AmountPaid += amount;
}

// Forced into one expression. It compiles. It is harder to read and harder to change.
public string StatusLabel => AmountPaid >= Total ? "Paid"
    : AmountPaid > 0m ? (IsOverdue ? "Part paid, overdue" : "Part paid")
    : IsOverdue ? "Overdue" : "Awaiting payment";

• Total needs a loop, and a loop is a statement rather than an expression, so the arrow form is not available. That restriction happens to agree with readability here.
• RecordPayment has two checks and then a change. Three ideas cannot be squeezed into one expression without conditional operators, and should not be.
• StatusLabel is the interesting case, because it can be written either way. The nested conditional version puts four outcomes and three tests on three lines, and adding a fifth outcome means re-reading all of it.
• A switch expression would be the better answer for StatusLabel — it is still one expression, so the arrow form stays, but each case sits on its own line. When a single expression grows conditional operators inside conditional operators, that is the signal to reach for pattern matching or a block.