Software design & coding fundamentals

public sealed class Order(Wallet wallet)
{
    public void Pay(decimal total, string reference)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(total);   // fail fast
        ArgumentException.ThrowIfNullOrWhiteSpace(reference);
        wallet.Debit(total, reference);    // tell, don't ask: Wallet checks funds
    }
}

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddScoped<IAccountRepository, SqlAccountRepository>();  // D
builder.Services.AddSingleton<IFeeRule, NppFee>();    // O: add a rule,
builder.Services.AddSingleton<IFeeRule, BpayFee>();   // edit nothing else
builder.Host.UseDefaultServiceProvider(o =>
{
    o.ValidateScopes = true;    // catch scoped services captured by singletons
    o.ValidateOnBuild = true;   // fail fast on missing registrations
});
// A consumer asks for IEnumerable<IFeeRule> to get every rule.

An interface with one implementation and no test fake is ceremony. Extract it when a second implementation or a seam appears.

// Factory delegate: the container builds the right client from config
builder.Services.AddSingleton<IFxRateClient>(sp =>
{
    var opts = sp.GetRequiredService<IOptions<FxOptions>>().Value;
    return opts.UseStub ? new StubFxClient() : new LiveFxClient(opts.BaseUrl);
});

// Prototype with records: copy, then change one field
public sealed record Payment(string Id, decimal Amount, int Attempt);
var retry = payment with { Attempt = payment.Attempt + 1 };

builder.Services.AddScoped<IFxRateService, FxRateService>();
builder.Services.Decorate<IFxRateService, CachedFxRateService>();   // Scrutor
builder.Services.Decorate<IFxRateService, LoggedFxRateService>();   // outermost

builder.Services.AddTransient<CorrelationIdHandler>();
builder.Services.AddHttpClient<FxApiClient>()
    .AddHttpMessageHandler<CorrelationIdHandler>();   // decorates HttpClient

builder.Services.AddChatClient(innerClient)   // IChatClient decorators
    .UseDistributedCache()
    .UseOpenTelemetry()
    .UseFunctionInvocation();

builder.Services.AddKeyedScoped<IPaymentRail, NppRail>("npp");
builder.Services.AddKeyedScoped<IPaymentRail, BpayRail>("bpay");

// Strategy fixed per endpoint
app.MapPost("/pay/npp",
    ([FromKeyedServices("npp")] IPaymentRail rail, PayRequest req) =>
        rail.SendAsync(req));

// Strategy chosen at runtime from the request
app.MapPost("/pay", (PayRequest req, IServiceProvider sp) =>
    sp.GetRequiredKeyedService<IPaymentRail>(req.Rail).SendAsync(req));

// ❌ Pay(string bsb, string acct, decimal amt, string cur, string reference)
// ✅ value object + parameter object
public readonly partial record struct Bsb
{
    public string Value { get; }
    public Bsb(string value) => Value = Format().IsMatch(value)
        ? value : throw new ArgumentException("BSB must be 000-000", nameof(value));

    [GeneratedRegex(@"^\d{3}-\d{3}$")]
    private static partial Regex Format();
}
public sealed record PaymentRequest(Bsb Bsb, string Account, decimal Amount,
    string Reference);

public ErrorOr<Transfer> Create(Account from, decimal amount)
{
    if (amount <= 0) return Error.Validation("amount", "Amount must be positive");
    if (from.Balance < amount) return Error.Conflict("funds", "Insufficient funds");
    return new Transfer(Guid.NewGuid(), from.Id, amount);   // happy path last
}

app.MapPost("/transfers", (TransferRequest req, Accounts accounts, TransferService svc) =>
    svc.Create(accounts.Get(req.FromId), req.Amount).Match<IResult>(
        t => TypedResults.Created($"/transfers/{t.Id}", t),
        errors => TypedResults.Problem(errors[0].Description,
            statusCode: errors[0].Type == ErrorType.Validation ? 400 : 409)));

using System.Collections.Frozen;

// Built once at startup, read millions of times
FrozenSet<string> supported = new[] { "AUD", "NZD", "USD", "EUR" }
    .ToFrozenSet(StringComparer.OrdinalIgnoreCase);

// ❌ O(n²): List.Contains inside a loop
// ✅ O(n): HashSet lookups
var seen = new HashSet<string>(capacity: payments.Count);
foreach (var p in payments)
    if (!seen.Add(p.IdempotencyKey)) Reject(p, "duplicate");

// Sliding window: longest substring with no repeated chars. O(n)
static int LongestDistinct(string s)
{
    var last = new Dictionary<char, int>();
    int best = 0, start = 0;
    for (int i = 0; i < s.Length; i++)
    {
        if (last.TryGetValue(s[i], out int seen) && seen >= start) start = seen + 1;
        last[s[i]] = i;
        best = Math.Max(best, i - start + 1);
    }
    return best;
}

// Top-k largest: keep a min-heap of size k. O(n log k)
static int[] TopK(int[] nums, int k)
{
    var heap = new PriorityQueue<int, int>();
    foreach (int n in nums)
    {
        heap.Enqueue(n, n);
        if (heap.Count > k) heap.Dequeue();   // drop the smallest
    }
    return [.. heap.UnorderedItems.Select(x => x.Element)];
}