Series · 15 parts
An Attendance Platform in ASP.NET Core
Badge gates, WFH timers and shift allowances - the shape of a seven-project intranet attendance platform, the onion it almost is, and the roadmap for fourteen more parts.
Topic
.NET
221 articles filed under this topic.
Series in .NET
Series · 4 parts
An Attendance Platform — The Frontend Chapters
A 6.23 MB JavaScript bundle loaded on every page, a manifest that minifies CSS but concatenates JS, and two copies of jQuery - the first of four frontend chapters the attendance series skipped.
Series · 9 parts
Archive-on-Delete with ArchiveKit
Hard deletes destroy the audit trail; soft deletes clutter live tables forever. Introducing ArchiveKit, a .NET library that intercepts deletions and stores immutable archive snapshots with TTL policies and cascade archiving.
Series · 8 parts
Contract Testing with Pactify
Unit tests mock what you assume, end-to-end tests tell you too late - consumer-driven contract testing closes the gap, and a small open-source .NET library called Pactify is the clearest way I know to learn how it works. Part 1 of a series.
Series · 8 parts
Convey — The Missing Chapters
The 22-part Convey series read the packages; it never once walked the sample system that ships with them. Opening the missing chapters with the trip an order takes through Orders, Pricing and Deliveries — and what the samples quietly teach that no package README does.
Series · 10 parts
Entity Versioning with VersionKit
Rename a property, change a type, ship the release - and every payload you stored last year stops deserialising. Introducing VersionKit, a .NET library that declares schema history as attributes and migrates old data on read.
Series · 17 parts
FastEndpoints in Depth
Controllers grow sideways and Minimal APIs grow into soup. FastEndpoints bets on a third shape - one class per endpoint - and this series reads its source to see how the bet is implemented. Part 1 of FastEndpoints in Depth.
Series · 12 parts
FastEndpoints — The Missing Chapters
Seventeen parts of reading FastEndpoints and the series never once mentioned mappers - the entity-translation layer half the endpoint base classes exist to serve. The Missing Chapters opens with the biggest gap: where mappers live, how they are found, and why they are secretly singletons. Part 1 of FastEndpoints — The Missing Chapters.
Series · 22 parts
Microservices with Convey
Every team's fifth microservice ships with the same four hundred lines of bootstrap code as the first four. Opening a deep-dive series on Convey, the open-source .NET toolkit that turned that boilerplate into thirty composable packages.
Series · 10 parts
Multi-Tenancy in .NET with EF Core
Database-per-tenant, schema-per-tenant, or packed into a shared database? Kicking off a series on building a multi-tenant platform where one EF Core codebase supports all three isolation strategies behind a single control plane.
Series · 15 parts
Nine Services and a Message Bus
DShop is one e-commerce shop stamped out as nine microservices over RabbitMQ - this series reads the real source to see how the topology holds together and where it drifts. Part 1 of Nine Services and a Message Bus.
Series · 11 parts
Real-Time Feeds with FeedR
A guided tour of FeedR, DevMentors' open-source .NET microservices sample for real-time data feeds - six services, Redis pub/sub, Apache Pulsar and a gRPC stream, and the two-tier eventing model that makes it worth reading. Part 1 of a source-level deep dive.
Series · 9 parts
Sagas with Chronicle
Split one database into five services and the transaction you deleted does not disappear - it goes feral. On sagas, compensation, process managers, and Chronicle, the small open-source .NET library this series reads line by line.
Series · 8 parts
Service Discovery Without a Service Mesh
Dozens of Azure Functions and Logic Apps need each other's URLs and keys, and there is no Kubernetes, no sidecar, no mesh to hand them out. How a small .NET library turned one Key Vault and a naming convention into a working discovery layer - the consumer side of a registry made of secrets. Part 1 of a new series.
Series · 13 parts
The Convey Consumer Tax
Convey sells a microservice in thirty lines, and Pacco builds ten of them - this series reads the whole estate to price what the framework compresses and what every consumer pays for by hand. Part 1 of The Convey Consumer Tax.
Series · 18 parts
The Database Is the Message Bus
Five executables, zero queues - how an attendance platform coordinated a web app, three Azure Functions and a console job through one SQL database, and what that choice bought and cost. Part 1 of the series.
Series · 16 parts
The Framework Before the Framework
DShop.Common is the shared library nine microservices were built on - and the rough draft of a framework its authors later shipped as Convey.
Series · 15 parts
The Order That Choreographs Itself
Nobody in Pacco approves an order - a vehicle reservation does. A tour of DevMentors' parcel-delivery estate, the domain it models, and the fifteen-part series it earns.
Coming soon in .NET
The Dashboard You Get for Free
Wire four services into a .NET Aspire AppHost and run it once - traces, logs, health and environment variables for the whole system, before you have written a single line of observability code. Part 1 of a series on Aspire in production.
Standalone articles
Getting Transactions Right with EF Core
SaveChanges is already a transaction, until it isn't enough. A tour of explicit transactions, TransactionScope, execution strategies and the failure modes that only show up in production.
JWTs and the Blacklist Problem
Convey's auth packages in two acts - a JWT layer that turns one config section into token issuing and validation, and the uncomfortable question every stateless system meets on logout day.
When Not to Use FastEndpoints
After sixteen parts inside the source, the honest retrospective - what the library gets right, the sharp edges that will cut you (singletons, statics, magic), and the projects where I would leave it on the shelf. Part 17, the conclusion of FastEndpoints in Depth.
Secrets Before Configuration: Convey and Vault
How Convey's Vault package loads secrets into IConfiguration before the container exists, turns dynamic database credentials into ordinary config keys, and renews leases in the background - plus the secret-zero problem it cannot solve.
Throttling, Idempotency, and an HTTP 402 Surprise
The cross-cutting drawer of FastEndpoints holds a rate limiter that documents its own limitations, idempotency built on output caching, server-sent events - and a full implementation of the x402 micro-payments protocol. Part 16 of FastEndpoints in Depth.
Discovery and Load Balancing Before the Mesh
How Convey wires Consul registration, health-gated deregistration and client-side balancing - and why Fabio exists to take the balancing decision back out of your process.
Trading Reflection for Roslyn: Source Generators and Native AOT
Everything FastEndpoints does with reflection - discovery, setters, factories - has a compile-time twin in its source generators, and following that migration is a case study in making a reflection-heavy library AOT-ready. Part 15 of FastEndpoints in Depth.
Typed Clients Over One HTTP Door
Convey's HTTP story in two layers - a hardened IHttpClient with retries, masking and correlation headers, and RestEase interfaces on top that turn a service name in config into a typed client.
Route-less Tests: Integration Testing With Typed Clients
FastEndpoints ships a testing package where tests call endpoints by class name, apps boot once per fixture, and even command handlers can be faked - the route string never appears in a test. Part 14 of FastEndpoints in Depth.
Persistence as a Registration: Mongo and Redis
What you get when a chassis reduces MongoDB to one builder call and a named collection - a generic repository, paging, camelCase conventions, a seeding hook - and the transactions and indexes it deliberately leaves on your desk.
A Job Queue Is a Command With a Tracking ID
FastEndpoints' job queues persist commands through a storage provider you supply and execute them with a semaphore design that idles without polling. The state machine in JobQueue.cs is worth the read on its own. Part 13 of FastEndpoints in Depth.
The Outbox That Keeps Your Events Honest
Save the order, publish the event, crash in between - the dual-write problem, and how Convey's outbox and inbox turn at-least-once messaging into something you can build a business on.
Commands Over gRPC, No Proto Files
FastEndpoints.Messaging.Remote executes the same ICommand on another machine over gRPC, serialized with MessagePack instead of protobuf contracts - plus an event hub mode that turns a server into a lightweight broker. Reading it explains both the magic and the trade. Part 12 of FastEndpoints in Depth.
What FeedR Gets Right, and What Production Would Add
The retrospective: after ten parts inside DevMentors' real-time feeds sample, the honest scorecard - five decisions worth stealing for real systems, the sharp edges catalogued in one place, and the concrete backlog that separates this teaching codebase from a production deployment. Part 11 closes the FeedR deep dive.
Commands and Events on the Wire
Convey's broker-CQRS bridge is seventy lines of code that make the same handler serve local dispatch and RabbitMQ delivery — one line per subscription, correlation context riding along for free.
An Event Bus and a Command Bus, No Extra Package Required
FastEndpoints ships in-process messaging that covers most MediatR use cases - events with three wait modes, commands with middleware pipelines, generic and streaming handlers. The dispatch code makes some sharp lifetime choices worth knowing. Part 11 of FastEndpoints in Depth.
Six Services on a Laptop
FeedR ships three ways to run its six services - pm2, Project Tye, and a deliberately split pair of docker compose files - plus per-service Dockerfiles and an environment-keyed configuration layer that lets the same build run on localhost and inside a compose network. Part 10 of the FeedR deep dive.
Retries, Dead Letters, and the Plugin Chain
What Convey's RabbitMQ subscriber actually does when your handler throws - fixed-interval retries, an exception-to-message escape hatch, a dlx- safety net, and one plugin that can quietly defeat all of it.
Teaching NSwag What Your Endpoints Mean
FastEndpoints' Swagger support is a thousand-line translation layer that knows which DTO properties are route params, which FluentValidation rules are schema constraints, and which endpoint versions belong in which document. Part 10 of FastEndpoints in Depth.
Testing a Message You Can't Await
How do you assert that an endpoint published an event when publishing is a side effect with no return channel? FeedR's end-to-end test answers with WebApplicationFactory, a real Redis round-trip, and a TaskCompletionSource - plus the timeout and determinism traps the sample leaves open. Part 9 of the FeedR deep dive.
RabbitMQ by Convention
How Convey's RabbitMQ package turns a class name into an exchange, a routing key and a queue - two eager connections, a channel per thread, and a topology you never declare by hand.
When a Saga Library Is Overkill
Eight parts of source-reading later, the honest retrospective. What Chronicle gets right, the timeout-shaped hole at its centre, how it stacks up against MassTransit and NServiceBus and durable execution - and the cases where a status column beats every saga framework ever written.
Versioning at the End of the Route
FastEndpoints suffixes versions by default - /api/orders/v2 - and its release-group model versions endpoints, not APIs. Reading the route-building code explains the philosophy, and the AspVersioning bridge covers everyone it doesn't fit. Part 9 of FastEndpoints in Depth.
When Contract Testing Pays for Itself
The series retrospective - what a thirty-file library taught me that a full-featured one couldn't, Pactify's honest limit list versus PactNet, the broker maturity ladder, and the org-shaped question hiding under the tooling.
One Correlation ID Across Three Transports
FeedR threads a correlation ID from a YARP transform through HTTP middleware and into Pulsar message metadata - and quietly loses it at the Redis hop in the middle. Tracing exactly where the chain holds and where it breaks is the best observability lesson in the sample. Part 8 of the FeedR deep dive.
A Message Broker Behind an Interface
Convey's messaging abstraction is two interfaces and an attribute - and the naming conventions underneath them quietly turn your C# class names into a public wire contract.