Beyond "It Works".

public void Withdraw(Account acc, decimal amount)
{
    if (amount <= 0)
        throw new Exception("Bad amount");
    if (amount > acc.Balance)
        throw new Exception("Can't do that");
    if (acc.IsFrozen)
        throw new Exception("Nope");
}

// Caller has to parse strings...
try { Withdraw(acc, 500); }
catch (Exception e)
{
    if (e.Message.Contains("Bad")) // fragile
        ...
}

public class InvalidAmountException : ArgumentException
{
    public InvalidAmountException(decimal amount)
        : base($"Amount must be positive, got {amount}") { }
}

public class InsufficientFundsException : Exception
{
    public decimal Shortfall { get; }
    public InsufficientFundsException(decimal bal, decimal req)
        : base($"Need £{req}, have £{bal}")
        => Shortfall = req - bal;
}

public class AccountFrozenException : Exception { }

// Caller handles each case precisely
try { Withdraw(acc, 500); }
catch (InsufficientFundsException e)
    { SuggestLowerAmount(e.Shortfall); }
catch (AccountFrozenException)
    { ShowContactSupport(); }

public string BuildWelcomeMessage(User user)
  {
    // Crashes if any nested property is null
    var first = user.Profile.FirstName.Trim();
    var plan = user.Subscription.PlanName.ToUpper();
    return $"Welcome {first} • {plan}";
  }

public string BuildWelcomeMessage(User? user)
  {
    if (user is null)
      return "Welcome Guest • FREE";

    var first = string.IsNullOrWhiteSpace(user.Profile?.FirstName)
      ? "Guest"
      : user.Profile.FirstName.Trim();

    var plan = string.IsNullOrWhiteSpace(user.Subscription?.PlanName)
      ? "FREE"
      : user.Subscription.PlanName.ToUpperInvariant();

    return $"Welcome {first} • {plan}";
  }

public async Task<Quote> GetQuote(string symbol)
{
    // If provider hangs, this request hangs too
    var res = await _http.GetAsync(
        $"/quotes/{symbol}");

    res.EnsureSuccessStatusCode();
    return await res.Content.ReadFromJsonAsync<Quote>();
}

public async Task<QuoteResult> GetQuote(
    string symbol,
    CancellationToken requestCt)
{
    using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
    using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
        requestCt, timeoutCts.Token);

    try
    {
        var res = await _http.GetAsync(
            $"/quotes/{symbol}", linkedCts.Token);

        if (!res.IsSuccessStatusCode)
            return QuoteResult.Fail("provider_error");

        var quote = await res.Content.ReadFromJsonAsync<Quote>(
            cancellationToken: linkedCts.Token);

        return quote is null
            ? QuoteResult.Fail("empty_payload")
            : QuoteResult.Ok(quote);
    }
    catch (OperationCanceledException) when (timeoutCts.IsCancellationRequested)
    {
        _metrics.Increment("quotes.timeout");
        return QuoteResult.Fail("provider_timeout");
    }
    catch (OperationCanceledException)
    {
        // User/request aborted
        throw;
    }
}

public class InvoiceService
{
    private readonly SmtpClient _smtp = new();
    private readonly SqlInvoiceRepo _repo = new();

    public async Task SendInvoice(Invoice i)
    {
        await _repo.Save(i);
        await _smtp.SendMailAsync(i.Email, "Invoice", "Attached");
    }
}

public class InvoiceService
{
    private readonly IInvoiceRepository _repo;
    private readonly IEmailSender _email;

    public InvoiceService(IInvoiceRepository repo, IEmailSender email)
    {
        _repo = repo;
        _email = email;
    }

    public async Task SendInvoice(Invoice i)
    {
        await _repo.Save(i);
        await _email.Send(i.Email, "Invoice", "Attached");
    }
}

// composition root
services.AddScoped<IInvoiceRepository, SqlInvoiceRepo>();
services.AddScoped<IEmailSender, SmtpEmailSender>();

public class OrderService
{
    public async Task PlaceOrder(Order o)
    {
        Validate(o);
        await _db.Save(o);
        await _payment.Charge(o.Total);
        await _mailer.Send(o.Email, "Order placed");
        _logger.LogInformation("Order {Id} placed", o.Id);
    }
}

public class OrderApplicationService
{
    private readonly IOrderValidator _validator;
    private readonly IOrderRepository _repo;
    private readonly IPaymentGateway _payments;
    private readonly IOrderNotifier _notifier;

    public async Task PlaceOrder(Order o)
    {
        _validator.Validate(o);
        await _payments.Charge(o.Total);
        await _repo.Save(o);
        await _notifier.NotifyPlaced(o);
    }
}

public class TransferController : ControllerBase
{
    [HttpPost]
    public async Task<IActionResult> Transfer(TransferDto dto)
    {
        var from = await _db.Accounts.FindAsync(dto.FromId);
        var to = await _db.Accounts.FindAsync(dto.ToId);
        from.Balance -= dto.Amount;
        to.Balance += dto.Amount;
        await _db.SaveChangesAsync();
        return Ok();
    }
}

public interface IAccountRepositoryPort
{
    Task<Account?> Get(AccountId id);
    Task Save(Account account);
}

public class TransferFundsUseCase
{
    private readonly IAccountRepositoryPort _accounts;

    public TransferFundsUseCase(IAccountRepositoryPort accounts)
        => _accounts = accounts;

    public async Task Execute(TransferCommand cmd)
    {
        var from = await _accounts.Get(cmd.From);
        var to = await _accounts.Get(cmd.To);
        from!.Debit(cmd.Amount);
        to!.Credit(cmd.Amount);
        await _accounts.Save(from);
        await _accounts.Save(to);
    }
}

// Adapter implementation plugs into EF Core, Dapper, etc.