Design case studies

const string Alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

static string ToBase62(long n)                   // 125 => "21" (2×62 + 1)
{
    if (n == 0) return "0";
    Span<char> buf = stackalloc char[11];        // long.MaxValue fits in 11 chars
    int i = buf.Length;
    while (n > 0) { buf[--i] = Alphabet[(int)(n % 62)]; n /= 62; }
    return new string(buf[i..]);
}

app.MapGet("/{code}", async (string code, HybridCache cache, LinksDb db, CancellationToken ct) =>
{
    var url = await cache.GetOrCreateAsync($"link:{code}",
        async token => await db.Links.Where(l => l.Code == code)
                                     .Select(l => l.LongUrl).FirstOrDefaultAsync(token),
        cancellationToken: ct);
    return url is null ? Results.NotFound() : Results.Redirect(url, permanent: false);  // 302
});

Only redirect to URLs you validated at creation time (http/https only), or the shortener becomes an open-redirect tool for phishing.

const string TokenBucketLua = """
    local cap, rate = tonumber(ARGV[1]), tonumber(ARGV[2])          -- capacity, tokens/sec
    local t = redis.call('TIME'); local now = t[1] + t[2] / 1000000  -- Redis clock, not ours
    local b = redis.call('HMGET', KEYS[1], 'tokens', 'ts')
    local tokens = math.min(cap, (tonumber(b[1]) or cap) + (now - (tonumber(b[2]) or now)) * rate)
    local ok = 0
    if tokens >= 1 then tokens = tokens - 1; ok = 1 end
    redis.call('HSET', KEYS[1], 'tokens', tokens, 'ts', now)
    redis.call('EXPIRE', KEYS[1], math.ceil(cap / rate) * 2)
    return { ok, math.floor(tokens) }
    """;

app.Use(async (ctx, next) =>
{
    var client = ctx.User.FindFirst("client_id")?.Value ?? $"ip:{ctx.Connection.RemoteIpAddress}";
    RedisResult[] r;
    try { r = (RedisResult[])(await redis.ScriptEvaluateAsync(TokenBucketLua, [new RedisKey($"rl:default:{client}")], [100, 10]))!; }
    catch (Exception e) when (e is RedisException or TimeoutException) { await next(ctx); return; } // fail open

    ctx.Response.Headers["RateLimit-Policy"] = "\"default\";q=100;w=10";
    ctx.Response.Headers["RateLimit"] = $"\"default\";r={(int)r[1]}";
    if ((int)r[0] == 0) { ctx.Response.StatusCode = 429; ctx.Response.Headers.RetryAfter = "1"; return; }
    await next(ctx);
});

The RateLimit / RateLimit-Policy headers are an IETF draft (draft-ietf-httpapi-ratelimit-headers), not an RFC yet. Many APIs still send the older RateLimit-Limit/Remaining/Reset or X-RateLimit-* names. Retry-After is the standard one.

[Authorize]
public sealed class ChatHub(IConnectionMultiplexer redis, IMessageStore store) : Hub
{
    public async Task<long> Send(string convId, Guid clientMsgId, string body)
    {
        // TODO: check the caller is a member of convId
        var db = redis.GetDatabase();
        long seq = await db.StringIncrementAsync($"seq:{convId}");          // order within the chat
        await store.AppendAsync(new ChatMessage(convId, seq, Context.UserIdentifier!, clientMsgId, body));
        await Clients.OthersInGroup(convId).SendAsync("message", convId, seq, body);
        return seq;                                                         // the ack: one tick
    }

    public Task Join(string convId) => Groups.AddToGroupAsync(Context.ConnectionId, convId);
}

builder.Services.AddSignalR().AddAzureSignalR();   // or .AddStackExchangeRedis(connString)

AppendAsync should be idempotent on clientMsgId (a resend after a lost ack must not create a second message). If INCR succeeds but the store fails, you get a gap in seq; clients must tolerate gaps.

// One limiter per SMS provider account: 100 msg/s, short queue for bursts
var smsQuota = new TokenBucketRateLimiter(new TokenBucketRateLimiterOptions
{
    TokenLimit = 100, TokensPerPeriod = 100, ReplenishmentPeriod = TimeSpan.FromSeconds(1),
    QueueLimit = 1_000, QueueProcessingOrder = QueueProcessingOrder.OldestFirst
});

// Separate processors for "sms-high" and "sms-low"; high gets more MaxConcurrentCalls
processor.ProcessMessageAsync += async args =>
{
    var job = args.Message.Body.ToObjectFromJson<SmsJob>()!;
    using RateLimitLease lease = await smsQuota.AcquireAsync(1, args.CancellationToken);
    if (!lease.IsAcquired) { await args.AbandonMessageAsync(args.Message); return; }   // try again later

    var sent = await sms.SendAsync(job.From, job.To, job.Text, cancellationToken: args.CancellationToken);
    await tracking.MarkSentAsync(job.NotificationId, "sms", sent.Value.MessageId);
    await args.CompleteMessageAsync(args.Message);
};
// An exception means the message is redelivered; after MaxDeliveryCount it moves to the DLQ

Set AutoCompleteMessages = false on the processor when you complete messages yourself. A limiter inside one worker only limits that worker: with 5 replicas, give each 1/5 of the provider rate or use a shared Redis bucket (21.2).

public async Task FanOutAsync(Post post, CancellationToken ct)
{
    if (await users.GetFollowerCountAsync(post.AuthorId, ct) > CelebrityThreshold)
        return;                                         // celebrities: readers pull instead

    double score = post.CreatedAt.ToUnixTimeMilliseconds();
    await foreach (long[] followers in follows.GetActiveFollowerPagesAsync(post.AuthorId, pageSize: 1_000, ct))
    {
        var batch = redis.CreateBatch();                // one round trip per 1,000 followers
        var writes = new List<Task>(followers.Length * 2);
        foreach (var f in followers)
        {
            writes.Add(batch.SortedSetAddAsync($"feed:{f}", post.Id, score));
            writes.Add(batch.SortedSetRemoveRangeByRankAsync($"feed:{f}", 0, -801));  // keep newest 800
        }
        batch.Execute();
        await Task.WhenAll(writes);
    }
}

// Durable Functions (isolated worker): fan out every segment x rung, then fan in
[Function(nameof(TranscodeVideo))]
public static async Task<string> TranscodeVideo(
    [OrchestrationTrigger] TaskOrchestrationContext ctx)
{
    var videoId = ctx.GetInput<string>()!;
    var segments = await ctx.CallActivityAsync<string[]>(nameof(Split), videoId);

    string[] ladder = ["1080p", "720p", "480p", "360p", "240p"];
    var encodes = from s in segments
                  from r in ladder
                  select ctx.CallActivityAsync<string>(nameof(Encode), new Job(s, r));
    string[] outputs = await Task.WhenAll(encodes);  // fan in: 10 min = 750 tasks

    return await ctx.CallActivityAsync<string>(nameof(Package), outputs);
}

[Function(nameof(Encode))]
public static async Task<string> Encode([ActivityTrigger] Job job)
{
    var output = Path.ChangeExtension(job.Segment, $".{job.Rung}.mp4");
    await FFMpegArguments.FromFileInput(job.Segment)
        .OutputToFile(output, true, o => o
            .WithVideoCodec(VideoCodec.LibX264)
            .WithVideoBitrate(Ladder.Kbps[job.Rung])
            .WithCustomArgument($"-vf scale=-2:{Ladder.Height[job.Rung]}"))
        .ProcessAsynchronously();
    return output;               // real code: download from / upload to Blob Storage
}

Azure Media Services was retired on 30 June 2024, so Azure has no first-party encode/package/DRM service any more: build with FFmpeg or buy (Mux, Cloudflare Stream, AWS Elemental MediaConvert, Google Transcoder API). FFMpegCore is MIT, but the ffmpeg binary you ship is LGPL, or GPL if built with parts like libx264: check your build. For very large fan-outs, use one sub-orchestration per rung to keep orchestration history small.

await using var tx = await db.Database.BeginTransactionAsync(ct);

db.Transactions.Add(new LedgerTx(txId, idempotencyKey, req.Reference));  // unique index on the key
db.Entries.AddRange(
    new Entry(txId, req.From, -req.AmountCents),      // money out
    new Entry(txId, req.To,   +req.AmountCents));     // money in: the entries sum to zero
db.Outbox.Add(OutboxMessage.From(new TransferPosted(txId)));
await db.SaveChangesAsync(ct);

int debited = await db.Accounts                         // atomic "no overdraw" check
    .Where(a => a.Id == req.From && a.AvailableCents >= req.AmountCents)
    .ExecuteUpdateAsync(s => s.SetProperty(a => a.AvailableCents, a => a.AvailableCents - req.AmountCents), ct);
if (debited == 0)
{
    await tx.RollbackAsync(ct);
    return Results.Problem("Insufficient funds", statusCode: 422);
}
await db.Accounts.Where(a => a.Id == req.To)
    .ExecuteUpdateAsync(s => s.SetProperty(a => a.AvailableCents, a => a.AvailableCents + req.AmountCents), ct);

await tx.CommitAsync(ct);
return Results.Created($"/transfers/{txId}", txId);

A duplicate idempotency key fails SaveChangesAsync with a unique-index violation: catch it and return the original result. Update the two accounts in ID order, not from/to order, to avoid deadlocks between opposite transfers.