What the Framework Doesn't Have
An audit of the messaging patterns DShop.Common leaves out - no outbox, no inbox, no consumed dead-letter - and how each absence became a Convey package.
Archive
Every article
Newest first, grouped by year. Search or filter by topic.
- 556 articles
- 334 matching
All
.NET
AI Engineering
Architecture
Azure & DevOps
Data Warehousing
Engineering Practice
Microservices
Web APIs
dotnet ×
The Retry Path Nobody Took
A complete broker-requeue retry implementation sits in DShop.Common's subscriber, fully written and never called - and its comment explains exactly why.
Rejected Events — a Two-Lane Error Taxonomy
DShop.Common decides a message's fate from the type of exception a handler throws - domain failures become events, infrastructure failures get retried.
The Envelope That Scrambled Itself
DShop.Common's correlation context threads request identity through every message hop - and a long positional argument list quietly transposes half its fields.
Command or Event, Enforced by Convention
In DShop.Common a command and an event are published by identical code - the difference between them is a marker interface and a promise nothing enforces.
Queue Names Are the Whole Topology
One naming class in DShop.Common decides every exchange, routing key and queue in the estate - the message topology is a string-formatting problem.
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.
The Ecosystem Around the Chassis
Convey did not appear from nowhere and it does not stand alone. DShop, Pacco, Ntrada, Chronicle, Pactify — the DevMentors constellation the toolkit grew out of and feeds into, which repo to study for what, and the close of both series.
From Clone to Chassis: The Onboarding Path
There is no dotnet new template and no CLI — Convey's onboarding is docs, samples and source. Reading the repo-of-repos layout and its packing scripts, then walking the actual path: build your first service from an empty project, one config section at a time.
Testing a Service Built on a Chassis
Twenty-two parts of source reading and not one about tests. How Convey's design choices land on your test suite: handlers that fake beautifully, an exposed host builder for integration tests, config flags as test infrastructure, and conventions that deserve a pin.
The Compose File Is the Architecture Diagram
Three toy services, ten infrastructure containers. Reading Convey's docker-compose stack as the honest bill of the chassis: what each container is for, which volumes actually persist, the per-OS variants, and what I would cut in 2026.
Two Outboxes, One Interface
The parent series covered the outbox pattern; it never compared the implementations. Entity Framework gets a real transaction, Mongo gets sessions you can switch off, expiry is three different mechanisms — and the processor that drains them all is a fire-and-forget timer.
One appsettings.json, Read Top to Bottom
Convey's real manifest is not Program.cs — it is the config file. Reading the Orders sample's appsettings.json as a single artifact: the section-per-package convention, the fleet of enabled:false switches, and what the defaults quietly tell you about production.
The Object Store in the Corner: Convey and OpenStack Swift
Convey.Persistence.OpenStack.OCS is the package the whole first series skipped — a hand-rolled Swift object-storage client with Keystone auth, an operation-result pattern, a server-side COPY verb, and a re-authentication habit worth learning from.
Three Services, One Order: The Sample System the Series Skipped
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.
Serving Your Contracts Over HTTP
Pactify.AspNetCore in one sitting: an attribute, an assembly scan, and a /pacts/{provider} endpoint that serves your contract classes as live JSON - plus what a runtime contracts endpoint is really for.
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.
How Pactify Decides You Broke the Contract
A line-by-line read of Pactify's matching engine - top-level-only body comparison, header names that ignore your casing option, nested objects that can never match, and two format-string bugs that crash the error path.
Publishing Pacts: From Shared Folder to Broker
How a pact travels from the consumer's pipeline to the provider's - Pactify's file and HTTP publishers, Pact Broker URL anatomy, and the unchecked response status that makes a failed publish silently pass your build.
Replaying the Contract Against a Real API
The provider side of Pactify - how CreateFor<Startup> hosts your whole API in memory with TestServer, why interactions verify concurrently, the SmartFormat trick behind endpoint templating, and the discovery that Given(...) never runs.
What's Inside a Pact File
An annotated tour of the JSON document Pactify produces - the serializer settings that shape it, the snake_case field inherited from Pact v1, and the unusual decision to ship the consumer's matching options inside the contract itself.
The Consumer Writes the Contract
A walk through Pactify's PactMaker fluent API - the two-interface builder trick that hides Build() from you, why the consumer test always passes, and the uninitialized-object surprise inside WithBody<T>().
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.
Your Integration Tests Are Lying to You
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.
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.