
<Sponsorships>

Nick Chapsas' Dometrain is celebrating 2 years of teaching .NET developers, and they are offering their
[**"From Zero to Hero: REST APIs in .NET"**](https://dometrain.com/course/from-zero-to-hero-rest-apis-in-asp-net-core/?ref=milan-jovanovic&promo=newsletter-20250614)
course for free.
Until the end of June, use the link below, and the course is yours to keep for 1 month.
[**Get it for free**](https://dometrain.com/course/from-zero-to-hero-rest-apis-in-asp-net-core/?ref=milan-jovanovic&promo=newsletter-20250614).

Get [**free senior engineer level code reviews**](https://fnf.dev/4l1jNMr) right in your IDE (VS Code, Cursor, Windsurf) with [**CodeRabbit**](https://fnf.dev/4l1jNMr).
Instantly catches bugs and code smells, suggests refactorings, and delivers context aware feedback for every commit, all without configuration.
Works with all major languages; trusted on 10M+ PRs across 1M repos and 70K+ OSS projects.
[**Install the extension and start vibe checking your code today**](https://fnf.dev/4l1jNMr).

</Sponsorships>

.NET 10 just got a whole lot more lightweight.

You can now run a C# file directly with:

```bash
dotnet run app.cs
```

That's it.
No `.csproj`.
No `Program.cs`.
No solution files.
Just a single C# file.

This new feature, introduced in [.NET 10 Preview 4](https://devblogs.microsoft.com/dotnet/announcing-dotnet-run-app/),
is a big step toward making C# more script-friendly, especially for quick utilities, dev tooling, and CLI-based workflows.

## Why This Matters

For years, C# has been perceived as heavyweight for small scripts.
Compare that to Python, Bash, or even JavaScript, where you can just write a file and run it.

That barrier is now gone.

You can now:

- Write one-off scripts in `.cs` files
- Use top-level statements
- Reference NuGet packages inline
- Share minimal reproducible examples without scaffolding a project

And it runs on **any OS** with the .NET SDK installed.

## Minimal Example

Here's a simple script that prints today's date:

```csharp
Console.WriteLine($"Today is {DateTime.Now:dddd, MMM dd yyyy}");
```

Run it:

```bash
dotnet run app.cs
```

Output:

```
Today is Saturday, Jun 14 2025
```

That's it.
No boilerplate, no boring `Main()` method.
Just top-level programs and C# code.

## Referencing NuGet Packages

Let's say you want to make an HTTP request using `Flurl.Http`.

You can do this inline:

```csharp
#:package Flurl.Http@4.0.2

using Flurl.Http;

var response = await "https://api.github.com"
    .WithHeader("Accept", "application/vnd.github.v3+json")
    .WithHeader("User-Agent", "dotnet-script")
    .GetAsync();

Console.WriteLine($"Status code: {response.StatusCode}");

Console.WriteLine(await response.GetJsonAsync<object>());
```

To run it:

```bash
dotnet run fetch.cs
```

Behind the scenes, the compiler downloads and restores NuGet dependencies automatically.

## Real-World Use Case: Seeding SQL Data

Here's a script I recently used to seed some test data into my Postgres database.

```csharp
#:package Dapper@2.1.66
#:package Npgsql@9.0.3

using Dapper;
using Npgsql;

const string connectionString = "Host=localhost;Port=5432;Username=postgres;Password=postgres";

using var connection = new NpgsqlConnection(connectionString);
await connection.OpenAsync();

using var transaction = connection.BeginTransaction();

Console.WriteLine("Creating tables...");

await connection.ExecuteAsync(@"
    CREATE TABLE IF NOT EXISTS users (
        id SERIAL PRIMARY KEY,
        name TEXT NOT NULL
    );
");

Console.WriteLine("Inserting users...");

for (int i = 1; i <= 10_000; i++)
{
    await connection.ExecuteAsync(
        "INSERT INTO users (name) VALUES (@Name);",
        new { Name = $"User {i}" });

    if (i % 1000 == 0)
    {
        Console.WriteLine($"Inserted {i} users...");
    }
}

transaction.Commit();

Console.WriteLine("Done!");
```

Why did I write this as a script?
I didn't want to clutter my app with throwaway seed logic.
I just needed a quick way to populate my database with test data.
This script does exactly that, and I can run it with:

```bash
dotnet run seed.cs
```

## File-Level Directives: The Magic Behind It

The real power comes from file-level directives.
These let you configure your app without leaving the .cs file:

**Package References**

```csharp
#:package Dapper@2.1.66
#:package Npgsql@9.0.3
```

**SDK Selection**

```csharp
#:sdk Microsoft.NET.Sdk.Web
```

This tells .NET to treat your file as a web application, enabling ASP.NET Core features:

```csharp
#:sdk Microsoft.NET.Sdk.Web
#:package Microsoft.AspNetCore.OpenApi@9.*

var builder = WebApplication.CreateBuilder();

builder.Services.AddOpenApi();

var app = builder.Build();

app.MapOpenApi();

app.MapGet("/", () => "Hello from a file-based API!");
app.MapGet("/users/{id}", (int id) => new { Id = id, Name = $"User {id}" });

app.Run();
```

You now have a running web API.
No project file.
No `Startup.cs`.
Just C# that does what you want.

**MSBuild Properties**

You can also set MSBuild properties directly in the file:

```csharp
#:property LangVersion preview
#:property Nullable enable
```

## When Your Script Grows Up

The brilliant part? When your file-based app gets complex enough to need project structure, converting is seamless:

```bash
dotnet project convert api.cs
```

This creates:

- A new folder named after your file
- A proper `.csproj` file with all your directives converted to MSBuild properties
- Your code moved to `api.cs` (or `Program.cs` if you prefer)
- Everything ready for full project development

Given our API example above, the generated `.csproj` looks like:

```xml
<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.*" />
  </ItemGroup>
</Project>
```

Your file-based app evolves naturally into a project-based app.
No need to rewrite or restructure everything.
This makes it easy to start small and grow as needed, without losing the simplicity of the initial script.

## Takeaway

The bottom line is this: C# just became significantly more approachable.
The barrier to entry dropped from "learn project files and MSBuild" to "write C# and run it."

For experienced developers, this is a productivity boost for scripting and prototyping.
For newcomers, this removes the biggest stumbling block to getting started with C#.

The best part?
Microsoft didn't create a separate scripting language or runtime.
They made regular C# easier to use.
Your file-based apps are real .NET applications that can grow into full projects when needed.

The ceremony is dead. Long live practical C#.

---



<Sponsorships>

[**EF Core is too slow**](https://entityframework-extensions.net/?utm_source=milanjovanovic&utm_medium=newsletter&utm_campaign=june-2025)? Discover how you can easily insert 14x faster (reducing saving time by 94%).
Boost your performance with our method integrated within EF Core: Bulk Insert, update, delete, and merge.
Join 5,000+ satisfied customers who have trusted our library since 2014.
[**Learn more**](https://entityframework-extensions.net/?utm_source=milanjovanovic&utm_medium=newsletter&utm_campaign=june-2025)

NET devs, your app's performance is trying to tell you something.
Are you listening?
[**Trace Explorer**](https://blog.sentry.io/find-and-fix-performance-bottlenecks-with-sentrys-trace-explorer/?utm_source=dotnetweekly&utm_medium=paid-community&utm_campaign=tracing-fy26q1-traceexplorer&utm_content=newsletter-dotnettracing-checkitout)
makes it easy to spot trends, find bottlenecks, and debug slow spans—without drowning in logs.
Search, filter, and aggregate to find what actually matters, like your slowest URLs, APIs & assets, jump straight to the culprit,
and get back to shipping cool stuff.
[**Check it out**](https://sentry.io/product/tracing/?utm_source=dotnetweekly&utm_medium=paid-community&utm_campaign=tracing-fy26q1-traceexplorer&utm_content=newsletter-dotnettracing-checkitout).

</Sponsorships>

I came across a Medium article with 700+ claps promoting this "SQL performance trick":

**"Filter Early, JOIN Later"**

<figure className="figure-center">
  <div className="bordered">
    <Image
      src="blogs/mnw_145/sql_performance_tip.png"
      width={910 * 0.75}
      height={906 * 0.75}
      alt="SQL performance tip that doesn't actually work."
    />
  </div>
  <figcaption>Source: SQL Tricks that Cut My Query Time by 80%</figcaption>
</figure>

The claim goes like this: instead of joining tables first and then filtering, you should filter in a subquery first, then join.

The supposed benefit?

> The database filtered the smaller table first, then did the JOIN — saving time and memory.

Here is the thing - this advice is **completely wrong** for modern databases.

Let me show you why with actual data.

## The Supposed "Optimization"

The article shows two queries. Here is the "bad" version:

```sql
SELECT *
FROM users u
JOIN orders o ON u.id = o.user_id
WHERE o.total > 500;
```

And the "optimized" version:

```sql
SELECT *
FROM (
  SELECT * FROM orders WHERE total > 500
) o
JOIN users u ON u.id = o.user_id;
```

The claim is that the second query is faster because it "filters first, then joins."

Sounds logical, right?
**Wrong.**

## Testing with Real Data

I tested both queries on a PostgreSQL database with:

- 10,000 users
- 5,000,000 orders (500 per user)
- Filtering for orders > $500

Let me run `EXPLAIN ANALYZE` on both queries to see what actually happens.

## The Results

Here are the execution plans for both queries:

**"Bad" Query Execution Plan:**

```
Hash Join  (cost=280.00..96321.92 rows=2480444 width=27) (actual time=1.014..641.202 rows=2499245 loops=1)
  Hash Cond: (o.user_id = u.id)
  ->  Seq Scan on orders o  (cost=0.00..89528.00 rows=2480444 width=14) (actual time=0.006..368.857 rows=2499245 loops=1)
        Filter: (total > '500'::numeric)
        Rows Removed by Filter: 2500755
  ->  Hash  (cost=155.00..155.00 rows=10000 width=13) (actual time=0.998..0.999 rows=10000 loops=1)
        Buckets: 16384  Batches: 1  Memory Usage: 577kB
        ->  Seq Scan on users u  (cost=0.00..155.00 rows=10000 width=13) (actual time=0.002..0.341 rows=10000 loops=1)
Planning Time: 0.121 ms
Execution Time: 685.818 ms
```

**"Optimized" Query Execution Plan:**

```
Hash Join  (cost=280.00..96321.92 rows=2480444 width=27) (actual time=1.019..640.613 rows=2499245 loops=1)
  Hash Cond: (orders.user_id = u.id)
  ->  Seq Scan on orders  (cost=0.00..89528.00 rows=2480444 width=14) (actual time=0.005..368.260 rows=2499245 loops=1)
        Filter: (total > '500'::numeric)
        Rows Removed by Filter: 2500755
  ->  Hash  (cost=155.00..155.00 rows=10000 width=13) (actual time=1.004..1.005 rows=10000 loops=1)
        Buckets: 16384  Batches: 1  Memory Usage: 577kB
        ->  Seq Scan on users u  (cost=0.00..155.00 rows=10000 width=13) (actual time=0.003..0.348 rows=10000 loops=1)
Planning Time: 0.118 ms
Execution Time: 685.275 ms
```

**The execution plans are identical.**

Both queries took ~685ms.
The "optimization" did absolutely nothing.

Here's the simplified execution plan, where I removed some details:

```
Hash Join
  Hash Cond: (o.user_id = u.id)
  ->  Seq Scan on orders o
        Filter: (total > '500'::numeric)
        Rows Removed by Filter
  ->  Hash
        ->  Seq Scan on users u
```

The core operations are:

1. Sequential Scan on `orders` table with filter applied
2. Sequential Scan on `users` table
3. Hash operation to build hash table from `users`
4. Hash Join using the hash condition on `user_id`

## Query Optimizers Are Smarter Than You

Modern databases use **cost-based optimizers**.
Here is what happens when you run a query:

1. **Parser** turns your SQL into an abstract syntax tree
2. **Optimizer** rewrites your query into the most efficient form
3. **Executor** runs the optimized plan

The optimizer looks at your query and says:
"I don't care how you wrote this. I will figure out the best way to execute it."

Both of our queries get rewritten to the same optimal plan:

- Filter the orders table first (because that eliminates rows early)
- Build a hash table from users (the smaller table)
- Hash join the filtered orders with users

**The optimizer already does the "optimization" automatically.**

Your manual subquery does not make it faster - it just makes your SQL harder to read.

## How Cost-Based Optimization Works

The query optimizer has statistics about your tables:

- Row counts
- Data distribution
- Index availability
- Column selectivity

It uses these stats to estimate the cost of different execution strategies:

- Which table to scan first
- Which join algorithm to use (hash, nested loop, merge)
- When to apply filters
- Which indexes to use

Then it picks the cheapest plan.
Your well-intentioned manual "optimization" gets ignored because the optimizer knows better.

## Summary

The "Filter Early, JOIN Later" advice is a relic from ancient database systems that did not have sophisticated optimizers.

Modern databases like PostgreSQL, MySQL, and SQL Server already do predicate pushdown and join reordering automatically.
Your manual "optimizations" are pointless and make code harder to maintain.

Write clear, readable SQL.
Let the optimizer do its job.

**The real lesson?**
Stop believing every performance tip you read online.
Use `EXPLAIN ANALYZE` to understand what your database is actually doing.

---



<Sponsorships>

You're Invited: [**Watch Postman's Keynote Talk, APIs in the Age of Autonomous Agents**](https://youtube.com/live/k_ZfWFP0hfs)
Can't be at POST/CON this year?
Don't worry—we've got you! Join Postman CEO Abhinav Asthana & Head of Marketing Justine Davis for this livestream keynote
event on June 4 at 9:00 AM PT as they talk through how APIs have evolved from simple endpoints to intelligent instructions for autonomous agents.
Learn how leading teams are standardizing design, automating testing, and scaling distribution in an AI-driven world.
[**Get notified and tune in live on YouTube**](https://youtube.com/live/k_ZfWFP0hfs)

Nick Chapsas' Dometrain is celebrating 2 years of teaching .NET developers, and they are offering their
[**"From Zero to Hero: REST APIs in .NET"**](https://dometrain.com/course/from-zero-to-hero-rest-apis-in-asp-net-core/?ref=milan-jovanovic&promo=newsletter-20250531)
course for free.
Until the end of June, use the link below, and the course is yours to keep for 1 month.
[**Get it for free**](https://dometrain.com/course/from-zero-to-hero-rest-apis-in-asp-net-core/?ref=milan-jovanovic&promo=newsletter-20250531).

</Sponsorships>

When you're building .NET applications, choosing the right **reverse proxy** can make a huge difference.
Two popular options keep coming up: Microsoft's [**YARP**](implementing-an-api-gateway-for-microservices-with-yarp) (Yet Another Reverse Proxy)
and the tried-and-true [**Nginx**](https://nginx.org/).

Here's the thing - everyone talks about which one is "better," but rarely do you see actual numbers.
So I decided to put both through the same tests and see what happens.

I'll test both proxies using the exact same API, same hardware, and same load testing approach.
No bias, just data.

## The Test API

I kept the test API super simple on purpose.
This way, we're measuring proxy performance, not how fast the backend can process complex requests:

```csharp
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/hello", () =>
{
    return Results.Ok("Hello world!");
});

app.Run();
```

This basic endpoint means we're testing the proxy itself, not waiting for complex business logic to run.

## YARP Configuration

YARP is pretty nice to work with if you're already in the .NET world. The setup is straightforward:

```csharp
var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));

var app = builder.Build();
app.MapReverseProxy();
app.Run();
```

It's equally simple to configure [**load balancing**](horizontally-scaling-aspnetcore-apis-with-yarp-load-balancing)
or [**authentication**](implementing-api-gateway-authentication-with-yarp).

The routing setup is clean and uses a `**catch-all` pattern to forward everything:

```json
{
  "ReverseProxy": {
    "Routes": {
      "default": {
        "ClusterId": "hello",
        "Match": { "Path": "{**catch-all}" }
      }
    },
    "Clusters": {
      "hello": {
        "Destinations": {
          "destination1": {
            "Address": "http://hello.api:8080"
          }
        }
      }
    }
  }
}
```

## Nginx Setup

For Nginx, I went with Docker to keep things simple.
The configuration does the same job as YARP:

```yml
nginx.proxy:
  image: nginx:alpine
  ports:
    - '3001:80'
  volumes:
    - ./nginx-proxy.conf:/etc/nginx/nginx.conf:ro
  depends_on:
    - hello.api
```

The Nginx config does exactly what YARP does - just with different syntax:

```nginx
events {}

http {
    upstream backend {
        server hello.api:8080;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
        }
    }
}
```

## Full Docker Compose Setup

Here's the complete `docker-compose.yml` that ties everything together:

```yml
services:
  hello.api:
    image: ${DOCKER_REGISTRY-}helloapi
    build:
      context: .
      dockerfile: Hello.Api/Dockerfile

  yarp.proxy:
    image: ${DOCKER_REGISTRY-}yarpproxy
    build:
      context: .
      dockerfile: Yarp.Proxy/Dockerfile
    ports:
      - 3000:8080
    depends_on:
      - hello.api

  nginx.proxy:
    image: nginx:alpine
    ports:
      - '3001:80'
    volumes:
      - ./nginx-proxy.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - hello.api
```

## Load Testing with k6

I used k6 to hit both proxies with the same load patterns.
I repeated the test with different numbers of virtual users (VUs) to see how each proxy handles increasing traffic.
This keeps things fair - same test, same conditions:

**YARP Test Script**:

```js
import http from 'k6/http';
import { check } from 'k6';

export let options = {
  scenarios: {
    yarp: {
      executor: 'per-vu-iterations',
      vus: 200, // 10, 50, 100, 200
      iterations: 1000,
      exec: 'testYarp',
      startTime: '0s'
    }
  }
};

export function testYarp() {
  let res = http.get('http://localhost:3000/hello');
  check(res, {
    'YARP: status 200': (r) => r.status === 200
  });
}
```

**Nginx Test Script**:

```js
import http from 'k6/http';
import { check } from 'k6';

export let options = {
  scenarios: {
    nginx: {
      executor: 'per-vu-iterations',
      vus: 200, // 10, 50, 100, 200
      iterations: 1000,
      exec: 'testNginx',
      startTime: '0s'
    }
  }
};

export function testNginx() {
  let res = http.get('http://localhost:3001/hello');
  check(res, {
    'NGINX: status 200': (r) => r.status === 200
  });
}
```

## Performance Results

Here's where things get interesting.
The numbers show a clear pattern:

```
| VUs  | YARP RPS | NGINX RPS | YARP p90 Latency (ms) | NGINX p90 Latency (ms) | YARP p95 Latency (ms) | NGINX p95 Latency (ms) |
|------|----------|-----------|-----------------------|------------------------|-----------------------|------------------------|
| 10   | 12692    | 9756      | 1.04                  | 1.10                   | 1.06                  | 1.52                   |
| 50   | 27080    | 10614     | 2.70                  | 5.23                   | 3.18                  | 5.68                   |
| 100  | 32432    | 10324     | 4.66                  | 10.61                  | 5.43                  | 10.96                  |
| 200  | 36662    | 10169     | 7.77                  | 21.23                  | 8.81                  | 21.92                  |
```

**Request per second (RPS)** is how many requests each proxy handled per second.

<Image
  src="blogs/mnw_144/rps_comparison.png"
  width={1750}
  height={760}
  alt="YARP vs Nginx RPS comparison"
/>

**p90 latency** is the time it took for 90% of requests to complete.

<Image
  src="blogs/mnw_144/p90_comparison.png"
  width={1750}
  height={760}
  alt="YARP vs Nginx p90 latency comparison"
/>

**p95 latency** is the time it took for 95% of requests to complete.

<Image
  src="blogs/mnw_144/p95_comparison.png"
  width={1750}
  height={760}
  alt="YARP vs Nginx p95 latency comparison"
/>

### Throughput Analysis

YARP really shines here.
It handles way more requests - almost 3.6x more at 200 users.
What's cool is how it scales up as you add more load.
Nginx stays pretty much flat around 10k requests per second, but YARP keeps climbing from 12k all the way to 36k.

### Latency Comparison

The latency story is even more impressive for YARP.
At 200 users, YARP keeps response times under 8ms while Nginx hits 21ms.
That's a big difference when you're trying to keep your app fast.

## Hold Up - That's Not Fair

Looking at these results, we're missing something important: **this comparison isn't fair to Nginx**.

The default Nginx configuration I used is fine for basic setups, but it's not optimized for high-throughput scenarios.
Nginx uses conservative defaults that work everywhere but don't push performance limits.

So let me fix the Nginx configuration and re-run the tests.

Here's the updated Nginx config with some tweaks to improve performance:

```nginx {1,4,19}
worker_processes auto;

events {
    worker_connections 65536;
    multi_accept on;
    use epoll;
}

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 30;
    keepalive_requests 1000;
    types_hash_max_size 4096;

    upstream backend {
        server hello.api:8080;
        keepalive 512;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://backend;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    }
}
```

## Performance Results - After Tuning

Here are the results after re-running the tests:

```
| VUs  | YARP RPS | NGINX RPS | YARP p90 Latency (ms) | NGINX p90 Latency (ms) | YARP p95 Latency (ms) | NGINX p95 Latency (ms) |
|------|----------|-----------|-----------------------|------------------------|-----------------------|------------------------|
| 10   | 12692    | 17572     | 1.04                  | 0.58                   | 1.06                  | 0.74                   |
| 50   | 27080    | 36687     | 2.70                  | 1.81                   | 3.18                  | 2.09                   |
| 100  | 32432    | 43289     | 4.66                  | 3.18                   | 5.43                  | 3.88                   |
| 200  | 36662    | 46850     | 7.77                  | 6.34                   | 8.81                  | 7.72                   |
```

<Image
  src="blogs/mnw_144/rps_comparison_tuned.png"
  width={1750}
  height={760}
  alt="YARP vs Nginx RPS comparison"
/>

<Image
  src="blogs/mnw_144/p90_comparison_tuned.png"
  width={1750}
  height={760}
  alt="YARP vs Nginx p90 latency comparison"
/>

<Image
  src="blogs/mnw_144/p95_comparison_tuned.png"
  width={1750}
  height={760}
  alt="YARP vs Nginx p95 latency comparison"
/>

### Throughput Analysis

Now this is more interesting.
Nginx actually edges out YARP in raw throughput - hitting 46k requests per second vs YARP's 36k at 200 users.
Both proxies scale well as load increases, but Nginx shows why it's been the go-to choice for high-traffic sites.

### Latency Comparison

The latency story is pretty close.
At lower loads, Nginx actually has better response times.
At 200 users, both proxies keep response times reasonable - YARP at 7.77ms and Nginx at 6.34ms for p90 latency.
The difference isn't huge either way.

## Key Takeaways

**Configuration matters more than you think**.
The initial results showed YARP crushing Nginx, but that was with Nginx's conservative defaults.
Once properly tuned, Nginx shows why it's been powering the internet for years.

**Nginx wins on raw performance**.
With proper configuration, Nginx handles more requests and keeps latency slightly lower.
That extra throughput matters when you're dealing with serious traffic.

**YARP offers better integration**.
Even though Nginx edges out performance, YARP feels natural in .NET projects.
Same configuration style, same patterns, same tooling.
Sometimes that developer experience is worth more than a few extra requests per second.

**Always tune your tools**.
This whole exercise shows why benchmarks with default configs can be misleading.
If you're choosing between these two, make sure you're comparing optimized configurations, not defaults.

The choice isn't as clear-cut as I initially thought.
Nginx wins on pure performance, but YARP wins on .NET integration.
Pick based on what matters more for your specific situation.

---



<Sponsorships>

Unlock the Power of [**ABP.IO's Core Modules**](https://abp.io/modules?utm_source=newsletter&utm_medium=affiliate&utm_campaign=milanjovanovic_may24)
and supercharge your .NET web app development:\
✅ SaaS - Build scalable, multi-tenant applications.\
✅ Identity & Permission Management - Handle authentication, roles, and claims.\
✅ Audit Logging - Track changes and user actions automatically.\
✅ Account - Get a full-featured, customizable user account UI.\
➡️ [**Explore ABP.IO Modules**](https://abp.io/modules?utm_source=newsletter&utm_medium=affiliate&utm_campaign=milanjovanovic_may24)
which are fully extensible and production-ready.

[**How to Migrate Your WPF Components to .NET MAUI**](https://www.telerik.com/blogs/how-to-migrate-wpf-components-net-maui?utm_medium=cpm&utm_source=milanjovanovich&utm_campaign=maui-general-awareness)\
Looking to modernize your WPF apps?
Discover how to seamlessly migrate your WPF components to .NET MAUI with Telerik's expert guide.
Learn best practices, avoid common pitfalls, and future-proof your desktop applications for cross-platform success.
[**Read the full guide**](https://www.telerik.com/blogs/how-to-migrate-wpf-components-net-maui?utm_medium=cpm&utm_source=milanjovanovich&utm_campaign=maui-general-awareness).

</Sponsorships>

Domain events are a powerful way to decouple parts of your system.
Instead of tightly coupling your logic, you can publish events and have other parts of your code subscribe to those events.
This pattern is especially valuable in [Domain-Driven Design](https://en.wikipedia.org/wiki/Domain-driven_design) (DDD)
where business logic should remain focused and cohesive.

In this article, we'll walk through how to implement a lightweight, custom domain event dispatcher in .NET.
The core dispatching logic should not depend on third-party libraries.

We'll cover:

- Why you might want to use publish-subscribe in your application
- How to define basic domain event abstractions
- How to implement and register handlers
- How to build a domain events dispatcher
- Trade-offs and when to consider other options

Let's get started.

## Why Domain Events Matter

Before diving into implementation, let's understand the problem domain events solve.
Consider this tightly coupled code:

```csharp
public class UserService
{
    public async Task RegisterUser(string email, string password)
    {
        var user = new User(email, password);
        await _userRepository.SaveAsync(user);
        
        // Directly coupled to email service
        await _emailService.SendWelcomeEmail(user.Email);
        
        // Directly coupled to analytics
        await _analyticsService.TrackUserRegistration(user.Id);
        
        // What if we need to add more features?
        // This method will keep growing...
    }
}
```

With domain events, we can decouple this:

```csharp
public class UserService
{
    public async Task RegisterUser(string email, string password)
    {
        var user = new User(email, password);
        await _userRepository.SaveAsync(user);
        
        // Publish event - let other parts of the system react
        await _domainEventsDispatcher.DispatchAsync(
            [new UserRegisteredDomainEvent(user.Id, user.Email)]);
    }
}
```

Now the `UserService` focuses solely on user registration, while other concerns are handled through event handlers.

## Basic Abstractions

Let's start by defining two simple interfaces that form the foundation of our event system:

```csharp
// Marker interface for all domain events.
public interface IDomainEvent
{
    // We could add common properties here like:
    // DateTime OccurredAt { get; }
    // Guid EventId { get; }
}

// Generic interface for handling domain events.
public interface IDomainEventHandler<in T> where T : IDomainEvent
{
    Task Handle(T domainEvent, CancellationToken cancellationToken = default);
}
```

This design gives us type safety through generic constraints while keeping publishers and handlers completely decoupled.
You can add new events or handlers without touching existing code, and everything remains easily testable in isolation.

## Implementing Sample Handlers

Let's add some sample handlers that demonstrate how different parts of your system can react to the same event:

```csharp
// Handles sending welcome emails when users register
internal sealed class SendWelcomeEmailHandler(IEmailService emailService) 
    : IDomainEventHandler<UserRegisteredDomainEvent>
{
    public async Task Handle(
        UserRegisteredDomainEvent domainEvent,
        CancellationToken cancellationToken = default)
    {
        // Send welcome email
        var welcomeEmail = new WelcomeEmail(domainEvent.Email, domainEvent.UserId);

        await emailService.SendAsync(welcomeEmail, cancellationToken);
    }
}

// Handles analytics tracking for new user registrations
internal sealed class TrackUserRegistrationHandler(IAnalyticsService analyticsService) 
    : IDomainEventHandler<UserRegisteredDomainEvent>
{
    public async Task Handle(
        UserRegisteredDomainEvent domainEvent,
        CancellationToken cancellationToken = default)
    {
        // Track registration in analytics
        await analyticsService.TrackEvent(
            "user_registered",
            new
            {
                user_id = domainEvent.UserId,
                registration_date = domainEvent.RegisteredAt
            },
            cancellationToken);
    }
}
```

To make this work, we need to register our handlers with the DI container.

Here's how to do it manually:

```csharp
// In your Program.cs or Startup.cs
services.AddScoped<IDomainEventHandler<UserRegisteredDomainEvent>, SendWelcomeEmailHandler>();
services.AddScoped<IDomainEventHandler<UserRegisteredDomainEvent>, TrackUserRegistrationHandler>();
```

Or you can automate this registration using [**assembly scanning with Scrutor**](improving-aspnetcore-dependency-injection-with-scrutor):

```csharp
services.Scan(scan => scan.FromAssembliesOf(typeof(DependencyInjection))
    .AddClasses(classes => classes.AssignableTo(typeof(IDomainEventHandler<>)), publicOnly: false)
    .AsImplementedInterfaces()
    .WithScopedLifetime());
```

The important thing is that multiple handlers can react to the same event.

## The Dispatcher (Strongly Typed)

Now we need something to orchestrate calling the handlers.
The dispatcher will take the domain events and call the appropriate handlers for each event.

```csharp {34,36}
public interface IDomainEventsDispatcher
{
    Task DispatchAsync(
        IEnumerable<IDomainEvent> domainEvents,
        CancellationToken cancellationToken = default);
}

internal sealed class DomainEventsDispatcher(IServiceProvider serviceProvider)
    : IDomainEventsDispatcher
{
    private static readonly ConcurrentDictionary<Type, Type> HandlerTypeDictionary = new();
    private static readonly ConcurrentDictionary<Type, Type> WrapperTypeDictionary = new();

    public async Task DispatchAsync(
        IEnumerable<IDomainEvent> domainEvents,
        CancellationToken cancellationToken = default)
    {
        foreach (IDomainEvent domainEvent in domainEvents)
        {
            using IServiceScope scope = serviceProvider.CreateScope();

            Type domainEventType = domainEvent.GetType();

            Type handlerType = HandlerTypeDictionary.GetOrAdd(
                domainEventType,
                et => typeof(IDomainEventHandler<>).MakeGenericType(et));

            IEnumerable<object?> handlers = scope.ServiceProvider.GetServices(handlerType);

            foreach (object? handler in handlers)
            {
                if (handler is null) continue;

                var handlerWrapper = HandlerWrapper.Create(handler, domainEventType);

                await handlerWrapper.Handle(domainEvent, cancellationToken);
            }
        }
    }

    // Abstract base class for strongly-typed handler wrappers
    private abstract class HandlerWrapper
    {
        public abstract Task Handle(IDomainEvent domainEvent, CancellationToken cancellationToken);

        public static HandlerWrapper Create(object handler, Type domainEventType)
        {
            Type wrapperType = WrapperTypeDictionary.GetOrAdd(
                domainEventType,
                et => typeof(HandlerWrapper<>).MakeGenericType(et));

            return (HandlerWrapper)Activator.CreateInstance(wrapperType, handler)!;
        }
    }

    // Generic wrapper that provides strong typing for handler invocation
    private sealed class HandlerWrapper<T>(object handler) : HandlerWrapper where T : IDomainEvent
    {
        private readonly IDomainEventHandler<T> _handler = (IDomainEventHandler<T>)handler;

        public override async Task Handle(
            IDomainEvent domainEvent,
            CancellationToken cancellationToken)
        {
            await _handler.Handle((T)domainEvent, cancellationToken);
        }
    }
}
```

The dispatcher uses a wrapper to eliminate reflection during handler execution while maintaining type safety.
When we encounter a `UserRegisteredDomainEvent`, we create a `HandlerWrapper<UserRegisteredDomainEvent>`
that holds a strongly-typed reference to `IDomainEventHandler<UserRegisteredDomainEvent>`.
The wrapper casts the generic `IDomainEvent` to the specific event type at runtime, but the actual handler invocation uses compile-time types.

This gives us the performance benefits of avoiding reflection in the hot path (handler execution) while only using reflection once during wrapper creation.
The trade-off is additional complexity, but the performance gain is significant if you're dispatching many events.

Don't forget to register the dispatcher with DI:

```csharp
services.AddTransient<IDomainEventsDispatcher, DomainEventsDispatcher>();
```

## Usage Example

Here's how to use the domain events dispatcher in your application:

```csharp
public class UserController(
    IUserService userService, 
    IDomainEventsDispatcher domainEventsDispatcher) : ControllerBase
{
    [HttpPost("register")]
    public async Task<IActionResult> Register([FromBody] RegisterUserRequest request)
    {
        try
        {
            // Create the user
            var user = await userService.CreateUserAsync(request.Email, request.Password);
            
            // Publish the domain event
            var userRegisteredEvent = new UserRegisteredDomainEvent(user.Id, user.Email);

            await domainEventsDispatcher.DispatchAsync([userRegisteredEvent]);
            
            return Ok(new { UserId = user.Id, Message = "User registered successfully" });
        }
        catch (Exception ex)
        {
            return BadRequest(new { Error = ex.Message });
        }
    }
}
```

You could also [**integrate domain events directly into your domain entities**](how-to-use-domain-events-to-build-loosely-coupled-systems).

## Limitations and Tradeoffs

This implementation runs entirely in-process, which has important implications.
All handlers execute synchronously within the same request context, but each gets its own DI scope.
This means:

- **Immediate feedback**:
  If any handler fails, the exception bubbles up to the caller immediately.
  No silent failures or eventual consistency surprises.

- **Caller control**:
  The code that dispatches events decides how to handle failures — rollback transactions, retry operations, or continue despite errors.
  The dispatcher doesn't make these decisions for you.

- **Reliability concerns**:
  If the process crashes after some handlers succeed but before others complete, there's no automatic recovery.
  Events aren't persisted or retried.

For critical side effects that can't be lost, consider the [**Outbox pattern**](implementing-the-outbox-pattern).
Instead of dispatching events immediately, store them alongside your business data in the same transaction.
A background service can later retry failed events, ensuring nothing gets lost.
This decouples reliability from performance — your main operation completes quickly while events are processed reliably in the background.

## Wrapping Up

Domain events are a powerful pattern for decoupling business logic, and you don't need a heavyweight framework to use them effectively.
The implementation we've built here provides a solid foundation that you can extend as your needs grow.

The beauty of rolling your own solution is that you understand every piece, making debugging and customization straightforward.
This pattern fits excellently in [**Domain-Driven Design**](/ddd-refactoring) and
[**Clean Architecture**](/pragmatic-clean-architecture) systems where decoupling business logic is crucial.

For systems requiring bulletproof reliability or cross-service communication, invest in proper message infrastructure.
But for many applications, this simple approach hits the sweet spot between coupling and complexity.

The key insight is understanding your trade-offs upfront rather than discovering them in production.
Start simple, measure what matters, and evolve based on real requirements.

---



<Sponsorships>

[**AWS Summit Washington DC: the Future of Cloud Innovation**](https://fnf.dev/4kGXJqr)\
Join AWS innovators at AWS Summit, June 10-11 in Washington DC, for deep dives on everything cloud from architecture to infrastructure.
340+ sessions with hands-on workshops, labs, interactive builder sessions led by AWS experts, “chalk talk” whiteboard sessions, and skillset-building training.
Learn from cutting-edge cloud technologists solving real-world challenges across industries.
[**FREE registration — claim your spot today!**](https://fnf.dev/4kGXJqr)

[**Design .NET Apps Visually with ABP Studio**](https://abp.io/studio?utm_source=newsletter&utm_medium=affiliate&utm_campaign=milanjovanovic_may17)\
Say goodbye to boilerplate and repetitive setup.
ABP Studio is your visual development tool for building modern, modular .NET applications—faster than ever.
Generate full-layered solutions, manage modules, entities, and UI from an intuitive interface — all fully aligned with the ABP.IO
No more context switching or manual coding for scaffolding. Just build, customize, and ship.
➡️ [**Download & Try ABP Studio today**](https://abp.io/studio?utm_source=newsletter&utm_medium=affiliate&utm_campaign=milanjovanovic_may17)

</Sponsorships>

MediatR is going commercial.

[Jimmy Bogard recently announced](https://www.jimmybogard.com/automapper-and-mediatr-going-commercial/)
that MediatR will adopt a commercial license model for companies above a certain size.

For many teams, this is a trigger to re-evaluate their usage and possibly look for alternatives.

And it's not a bad time to do so.
MediatR became almost synonymous with CQRS in .NET, despite the fact that [**CQRS and MediatR are not the same thing**](stop-conflating-cqrs-and-mediatr).
Most projects use it as a thin dispatching layer for commands and queries — a use case that can be covered with a few straightforward abstractions.

By removing MediatR, you gain:

- Full control over your CQRS infrastructure
- Predictable, explicit handler dispatching
- Simpler debugging and onboarding
- Cleaner DI setup and better testability

In this article, I'll walk you through building a minimal CQRS setup with just a few interfaces and support for decorators.
No hidden DI magic.
Just clean, predictable code.

We'll cover:

- Defining `ICommand`, `IQuery`, and handler contracts
- Adding support for decorators (logging, validation, etc.)
- Registering everything with DI
- A full working example in a real-world scenario

Let's get started.

## Commands, Queries, and Handlers

Let's start by defining the basic contracts for commands and queries.

```csharp
// ICommand.cs
public interface ICommand;
public interface ICommand<TResponse>;

// IQuery.cs
public interface IQuery<TResponse>;
```

These interfaces exist purely as markers.
They allow us to structure application logic around intention — write operations go through `ICommand`, read operations through `IQuery`.

The handler interfaces follow the same model:

```csharp
// ICommandHandler.cs
public interface ICommandHandler<in TCommand>
    where TCommand : ICommand
{
    Task<Result> Handle(TCommand command, CancellationToken cancellationToken);
}

public interface ICommandHandler<in TCommand, TResponse>
    where TCommand : ICommand<TResponse>
{
    Task<Result<TResponse>> Handle(TCommand command, CancellationToken cancellationToken);
}
```

```csharp
// IQueryHandler.cs
public interface IQueryHandler<in TQuery, TResponse>
    where TQuery : IQuery<TResponse>
{
    Task<Result<TResponse>> Handle(TQuery query, CancellationToken cancellationToken);
}
```

These are nearly identical to MediatR's `IRequest` and `IRequestHandler` APIs, making migration trivial if you're moving off of MediatR.

You'll notice we're using a `Result` wrapper for all return types.
This is optional, but it promotes explicit success/failure handling and encourages consistency across the application boundary.
You can learn more about it in my [**previous article**](functional-error-handling-in-dotnet-with-the-result-pattern).

These interfaces form a lightweight CQRS infrastructure, focused purely on intent and separation of concerns.
No mediator, no runtime indirection — just clear contracts for handling reads and writes.

## Practical Example: Command Handler

To see these abstractions in action, let's implement a command that marks a todo item as completed.

```csharp
// CompleteTodoCommand.cs
public sealed record CompleteTodoCommand(Guid TodoItemId) : ICommand;

// CompleteTodoCommandHandler.cs
internal sealed class CompleteTodoCommandHandler(
    IApplicationDbContext context,
    IDateTimeProvider dateTimeProvider,
    IUserContext userContext)
    : ICommandHandler<CompleteTodoCommand>
{
    public async Task<Result> Handle(CompleteTodoCommand command, CancellationToken cancellationToken)
    {
        TodoItem? todoItem = await context.TodoItems
            .SingleOrDefaultAsync(
                t => t.Id == command.TodoItemId && t.UserId == userContext.UserId,
                cancellationToken);

        if (todoItem is null)
        {
            return Result.Failure(TodoItemErrors.NotFound(command.TodoItemId));
        }

        if (todoItem.IsCompleted)
        {
            return Result.Failure(TodoItemErrors.AlreadyCompleted(command.TodoItemId));
        }

        todoItem.IsCompleted = true;
        todoItem.CompletedAt = dateTimeProvider.UtcNow;

        todoItem.Raise(new TodoItemCompletedDomainEvent(todoItem.Id));

        await context.SaveChangesAsync(cancellationToken);

        return Result.Success();
    }
}
```

A few important things to note:

- The command is an immutable value object (just data, no behavior).
- The handler encapsulates all business logic: validation, state change, raising domain events, and persistence.
- There's no mediator, no `ISender`, no hidden dispatching. The handler is invoked directly via our custom abstractions.

This makes intent explicit, avoids magic, and keeps the dependencies minimal.

We'll look at how to add decorators next, so we can introduce things like logging, validation, or transactions without modifying the handler itself.

## Decorators

To support cross-cutting concerns like logging, validation, and transactions, we apply the **decorator pattern** around our handlers.
Technically, this is closer to the **proxy pattern**, since we're injecting behavior before/after delegating to the real handler.
But in the context of cross-cutting concerns, most people refer to this as a decorator — which is fine for our purposes.

Let's look at two examples: one for logging, one for validation.

```csharp
using Serilog.Context;

internal sealed class LoggingCommandHandler<TCommand, TResponse>(
    ICommandHandler<TCommand, TResponse> innerHandler,
    ILogger<CommandHandler<TCommand, TResponse>> logger)
    : ICommandHandler<TCommand, TResponse>
    where TCommand : ICommand<TResponse>
{
    public async Task<Result<TResponse>> Handle(TCommand command, CancellationToken cancellationToken)
    {
        string commandName = typeof(TCommand).Name;

        logger.LogInformation("Processing command {Command}", commandName);

        Result<TResponse> result = await innerHandler.Handle(command, cancellationToken);

        if (result.IsSuccess)
        {
            logger.LogInformation("Completed command {Command}", commandName);
        }
        else
        {
            using (LogContext.PushProperty("Error", result.Error, true))
            {
                logger.LogError("Completed command {Command} with error", commandName);
            }
        }

        return result;
    }
}
```

This class wraps any `ICommandHandler<TCommand, TResponse>`, injecting the decorated handler as `innerHandler`.
It adds structured logging around the command execution without touching the core business logic.

Now a [**validation example with FluentValidation**](cqrs-validation-with-mediatr-pipeline-and-fluentvalidation):

```csharp
using FluentValidation;
using FluentValidation.Results;

internal sealed class ValidationCommandHandler<TCommand, TResponse>(
    ICommandHandler<TCommand, TResponse> innerHandler,
    IEnumerable<IValidator<TCommand>> validators)
    : ICommandHandler<TCommand, TResponse>
    where TCommand : ICommand<TResponse>
{
    public async Task<Result<TResponse>> Handle(TCommand command, CancellationToken cancellationToken)
    {
        // Validate the command using all registered validators
        ValidationFailure[] validationFailures = await ValidateAsync(command, validators);

        if (validationFailures.Length == 0)
        {
            return await innerHandler.Handle(command, cancellationToken);
        }

        // If validation fails, return a failure result with the errors
        return Result.Failure<TResponse>(CreateValidationError(validationFailures));
    }

    private static async Task<ValidationFailure[]> ValidateAsync<TCommand>(
        TCommand command,
        IEnumerable<IValidator<TCommand>> validators)
    {
        if (!validators.Any())
        {
            return [];
        }

        var context = new ValidationContext<TCommand>(command);

        ValidationResult[] validationResults = await Task.WhenAll(
            validators.Select(validator => validator.ValidateAsync(context)));

        ValidationFailure[] validationFailures = validationResults
            .Where(validationResult => !validationResult.IsValid)
            .SelectMany(validationResult => validationResult.Errors)
            .ToArray();

        return validationFailures;
    }

    private static ValidationError CreateValidationError(ValidationFailure[] validationFailures) =>
        new(validationFailures.Select(f => Error.Problem(f.ErrorCode, f.ErrorMessage)).ToArray());
}
```

Each decorator handles a single concern and can be layered transparently around the core handler.

**Important:** Since we're working with generic interfaces (`ICommandHandler<,>`, `IQueryHandler<,>`),
each decorator must explicitly target the same generic contract.
That means you'll need separate decorator classes for each handler abstraction you're using (e.g. command with result, command without result, query with result).

In the next section, we'll wire this up using [Scrutor](https://github.com/khellang/Scrutor).
It's a simple assembly scanning library that helps us register and decorate handlers cleanly.
Yes, it uses reflection, but only during startup — and it's fully transparent and predictable.

## DI Setup

With our handlers and decorators in place, we can register everything using Scrutor.

```csharp
services.Scan(scan => scan.FromAssembliesOf(typeof(DependencyInjection))
    .AddClasses(classes => classes.AssignableTo(typeof(IQueryHandler<,>)), publicOnly: false)
        .AsImplementedInterfaces()
        .WithScopedLifetime()
    .AddClasses(classes => classes.AssignableTo(typeof(ICommandHandler<>)), publicOnly: false)
        .AsImplementedInterfaces()
        .WithScopedLifetime()
    .AddClasses(classes => classes.AssignableTo(typeof(ICommandHandler<,>)), publicOnly: false)
        .AsImplementedInterfaces()
        .WithScopedLifetime());
```

This scans the application assembly and registers all command and query handlers (including internal types) as their respective interfaces.

Next, we apply decorators for validation and logging:

```csharp
services.Decorate(typeof(ICommandHandler<,>), typeof(ValidationDecorator.CommandHandler<,>));
services.Decorate(typeof(ICommandHandler<>), typeof(ValidationDecorator.CommandBaseHandler<>));

services.Decorate(typeof(IQueryHandler<,>), typeof(LoggingDecorator.QueryHandler<,>));
services.Decorate(typeof(ICommandHandler<,>), typeof(LoggingDecorator.CommandHandler<,>));
services.Decorate(typeof(ICommandHandler<>), typeof(LoggingDecorator.CommandBaseHandler<>));
```

Each `Decorate` call wraps the previous registration.
**Order matters**, but it might not be intuitive at first glance.

The last decorator applied will be the outermost one at runtime.
So in this example:

- The **base handler** is first decorated by **validation**
- That composite is then decorated again by **logging**

Which means the **logging decorator runs first**, followed by **validation**, and then the core handler.

This order allows logging to capture the full command lifecycle, including any early exits from validation failures.

With this setup, you now have a fully functional and extensible CQRS pipeline:

- Custom handler interfaces
- Clean decorator chain
- Assembly-scanned DI setup

## Usage from Minimal API

Once everything is wired up, using a command handler from a Minimal API endpoint is straightforward:

```csharp
internal sealed class Complete : IEndpoint
{
    public void MapEndpoint(IEndpointRouteBuilder app)
    {
        app.MapPut("todos/{id:guid}/complete", async (
            Guid id,
            ICommandHandler<CompleteTodoCommand> handler,
            CancellationToken cancellationToken) =>
        {
            var command = new CompleteTodoCommand(id);

            Result result = await handler.Handle(command, cancellationToken);

            return result.Match(Results.NoContent, CustomResults.Problem);
        })
        .WithTags(Tags.Todos)
        .RequireAuthorization();
    }
}
```

We're injecting the appropriate `ICommandHandler<CompleteTodoCommand>` directly into the endpoint.
No need for `ISender`, no mediator layer, no runtime lookup.

This keeps the endpoint clean and focused on its primary responsibility: handling HTTP requests.

Everything is resolved explicitly by the container.
This makes the code easier to test, reason about, and trace while maintaining all the benefits of CQRS and separation of concerns.

## Conclusion

CQRS doesn't require a complex framework.

With a few small interfaces, some decorator classes, and a clean DI setup, you can build a simple and flexible pipeline for handling commands and queries.
It's easy to understand, easy to test, and easy to extend.

If you want to see this pattern applied in a complete solution,
my [**free Clean Architecture template**](/templates/clean-architecture) includes everything covered in this article (fully wired up).

Use it as a reference or as a starting point for your next project.

---



<Sponsorships>

[**Aiven for OpenSearch®**](https://fnf.dev/3SpnQpp) is the fully managed, open source alternative to Elasticsearch - built for
high-performance, distributed search and analytics.
Spin up production-ready clusters in under 10 minutes, deploy to the cloud of your choice,
and offload the rest to Aiven so you can focus on building, not managing infrastructure.
[**Sign up for free and get additional $100 credits here!**](https://fnf.dev/3EW72Dy)

Code reviews are time-consuming.
[**CodeRabbit**](https://fnf.dev/3F2eDR1) is your AI co-pilot—instantly generating review comments, one-click fixes, and custom AST-grep rules.
It can even plan refactors and merge via chat.
Trusted on 10M+ PRs across 1M repos and 70K+ OSS projects.
[**Try Code Rabbit today and cut .NET code review time and bugs in half**](https://fnf.dev/3F2eDR1).

</Sponsorships>

If you've ever worked with a legacy C# codebase, you know the pain of an anemic domain model.
You have probably opened an `OrderService` (_all similarities to production code are merely a coincidence_) and thought _"this file does everything."_
Pricing logic, discount rules, stock checks, database writes — **all jam-packed into one class**.
It works — until it doesn't.
New features turn into **regression roulette**, and test coverage plummets because the domain is buried under infrastructure.

This is the classic symptom of an anemic domain model, where entities are nothing but data holders, and all logic lives elsewhere.
It makes the system harder to reason about, and every change becomes a guessing game.
But what if we could push behavior back into the domain, one rule at a time?

In this article, we'll:

1. **Inspect** a typical anemic implementation.
2. **Identify** hidden business rules that make it brittle.
3. **Refactor** toward a behavior-rich aggregate one refactor at a time.
4. **Highlight** the concrete payoffs so you can justify the change to teammates.

Everything fits in a 6-minute read, but the pattern scales to any legacy system.

## Starting Point: God-like Service Class

Below is an (unfortunately common) `OrderService`.
Besides calculating totals it also:

- applies a **5 % VIP discount**,
- throws if any product is **out of stock**, and
- rejects orders that would **exceed the customer's credit limit**.

```csharp
// OrderService.cs
public void PlaceOrder(Guid customerId, IEnumerable<OrderItemDto> items)
{
    var customer = _db.Customers.Find(customerId);
    if (customer is null)
    {
        throw new ArgumentException("Customer not found");
    }

    var order = new Order { CustomerId = customerId };

    foreach (var dto in items)
    {
        var inventory = _inventoryService.GetStock(dto.ProductId);
        if (inventory < dto.Quantity)
        {
            throw new InvalidOperationException("Item out of stock");
        }

        var price = _pricingService.GetPrice(dto.ProductId);
        var lineTotal = price * dto.Quantity;
        if (customer.IsVip)
        {
            lineTotal *= 0.95m; // 5% discount for VIPs
        }

        order.Items.Add(new OrderItem
        {
            ProductId = dto.ProductId,
            Quantity = dto.Quantity,
            UnitPrice = price,
            LineTotal = lineTotal
        });
    }

    order.Total = order.Items.Sum(i => i.LineTotal);

    if (customer.CreditUsed + order.Total > customer.CreditLimit)
    {
        throw new InvalidOperationException("Credit limit exceeded");
    }

    _db.Orders.Add(order);
    _db.SaveChanges();
}
```

### What's Wrong Here?

- **Scattered rules:** Discount application, stock validation, and credit-limit checks are buried inside the service.
- **Tight coupling:** `OrderService` must know about pricing, inventory, and EF Core just to place an order.
- **Painful testing:** Each unit test needs fakes for DB access, pricing, inventory, and VIP vs. non-VIP flows.

<div className='blockquote'>

**Goal:** Embed these rules **inside the domain** so the application layer only deals with orchestration.

</div>

## Guiding Principles Before We Touch Code

1. **Protect invariants close to the data.**
   Stock, discounts, and credit checks belong where the data lives — inside the `Order` aggregate.
2. **Expose intent, hide mechanics.**
   The application layer should read like a story: _"place order"_, not _"calculate totals, check credit, write to DB"_.
3. **Refactor in slices.**
   Each move is safe and compilable; no big-bang rewrites.
4. **Balance purity with pragmatism.**
   Move rules only when the payoff (clarity, safety, testability) beats the extra lines of code.

## Step-by-Step Refactor

The goal here isn't to chase purity or academic DDD.
It's to incrementally improve cohesion and make room for the domain to express itself.

At every step, we ask: Is this behavior something the domain should own?
If yes, we pull it inward.

### Embed Creation & Validation Logic

The first move is to make the aggregate responsible for building itself.
A static `Create` method gives us a single entry point where all invariants can fail fast.

While pushing stock validation into `Order` improves testability,
it does couple the order flow with inventory availability.
In some domains, you'd instead model this as a domain event and validate asynchronously.

```csharp
// Order.cs (Factory Method)
public static Order Create(
    Customer customer,
    IEnumerable<(Guid productId, int quantity)> lines,
    IPricingService pricingService,
    IInventoryService inventoryService)
{
    var order = new Order(customer.Id);

    foreach (var (productId, quantity) in lines)
    {
        if (inventoryService.GetStock(productId) < quantity)
        {
            throw new InvalidOperationException("Item out of stock");
        }

        var unitPrice = pricingService.GetPrice(productId);
        order.AddItem(productId, quantity, unitPrice, customer.IsVip);
    }

    order.EnsureCreditWithinLimit(customer);

    return order;
}
```

**Why?**
Creation now **fails fast** if any invariant is broken.
The service no longer micromanages stock or discounts.

Notice how we're now following the "Tell, Don't Ask" principle.
Rather than the service checking conditions and then manipulating the Order,
we're telling the Order to create itself with the necessary validations built in.
This is a fundamental shift toward **encapsulation**.

**💡 On Injecting Services into Domain Methods**

Passing services like `IPricingService` or `IInventoryService` into a domain method such as `Order.Create` might seem unconventional at first glance.
But it's a deliberate design choice: it keeps the orchestration inside the domain model, where the business logic naturally belongs,
instead of bloating the application service with procedural workflows.

This approach maintains the entity's autonomy while still aligning with dependency injection principles — dependencies are passed explicitly, not resolved from within.
It's a powerful technique, but one that should be used selectively — only when the operation clearly fits within the domain's responsibility
and benefits from direct access to external services.

### Guard the Aggregate's Internal State

```csharp
// Order.cs (excerpt)
private readonly List<OrderItem> _items = new();
public IReadOnlyCollection<OrderItem> Items => _items.AsReadOnly(); // C# 12 -> [.._items]

private void AddItem(Guid productId, int quantity, decimal unitPrice, bool isVip)
{
    if (quantity <= 0)
    {
        throw new ArgumentException("Quantity must be positive");
    }

    var finalPrice = isVip ? unitPrice * 0.95m : unitPrice;
    _items.Add(new OrderItem(productId, quantity, finalPrice));

    RecalculateTotal();
}

private void EnsureCreditWithinLimit(Customer customer)
{
    if (customer.CreditUsed + Total > customer.CreditLimit)
    {
        throw new InvalidOperationException("Credit limit exceeded");
    }
}
```

**Why bother?**

- **Encapsulation**: Consumers can't mutate `_items` directly, ensuring invariants hold.
- **Self-protection**: The domain model protects its own consistency rather than relying on service-level checks.
- **True OOP**: Objects now combine data and behavior, as object-oriented programming intended.
- **Simpler services**: Application services can focus on coordination rather than business rules.

### Shrink the Application Layer to Pure Orchestration

```csharp
public void PlaceOrder(Guid customerId, IEnumerable<OrderLineDto> lines)
{
    var customer = _db.Customers.Find(customerId);
    if (customer is null)
    {
        throw new ArgumentException("Customer not found");
    }
    var input = lines.Select(l => (l.ProductId, l.Quantity));

    var order = Order.Create(customer, input, _pricingService, _inventoryService);

    _db.Orders.Add(order);
    _db.SaveChanges();
}
```

The `PlaceOrder` method drops from **44 lines** to **14**, with **zero business logic**.

## What We Gained

**Before the refactor**

- Service owned pricing, stock, discount, and credit checks.
- Unit tests required heavy EF Core and service fakes.
- Adding a new rule meant touching multiple files.

**After the refactor**

- Aggregate owns all business rules; service only orchestrates.
- Pure domain tests — no database container required.
- Most changes are isolated to the `Order` aggregate.

## Wrapping Up

The real value in refactoring anemic models isn't technical — it's strategic.

By moving business logic closer to the data, you:

- Reduce the blast radius of changes
- Make business rules explicit and testable
- Open the door for tactical patterns like validation, events, and invariants

But you don't need a big rewrite.
Start with one rule.
Refactor it.
Then the next.

That's how legacy systems evolve into maintainable architectures.

If you enjoyed this breakdown and want a hands-on, real-world guide to untangling messy services,
check out my course [**Domain-Driven Design Refactoring**](/ddd-refactoring).
It's packed with before-and-after examples like this one.

---



<Sponsorships>

[**POST/CON 25**](https://fnf.dev/3EROWlV): Build Smarter APIs for an AI-Driven World\
Join 2,000+ engineers at POST/CON 25, June 3 & 4 in LA, for deep dives on building scalable APIs,
automating with Flows, and deploying AI-native systems. 30+ sessions, hands-on workshops, and zero
fluff. Learn from Postman engineers and peers solving real-world problems.
[**Register with code PMN50CAM1 for 50% off**](https://fnf.dev/3EROWlV)

Stack traces > “it just broke” — [**Sentry for .NET**](https://sentry.io/for/dot-net/?utm_source=dotnetweekly&utm_medium=paid-community&utm_campaign=errors-fy26q1-evergreen&utm_content=newsletter-itbroke-trysentry)
gets it.
NullReferenceException: object not set to an instance of anything remotely helpful.
Sentry captures the full error, request, and user context so you can stop debugging production like it's a murder mystery.
👉 [**Start fixing with Sentry — free trial, no guessing**](https://sentry.io/for/dot-net/?utm_source=dotnetweekly&utm_medium=paid-community&utm_campaign=errors-fy26q1-evergreen&utm_content=newsletter-itbroke-trysentry).

</Sponsorships>

[Event-driven architecture](https://en.wikipedia.org/wiki/Event-driven_architecture) (EDA) can make applications more flexible and reliable.
Instead of one part of the system calling another directly, we let events flow through a message broker.
In this quick guide, I'll show you how to set up a simple event-driven system in .NET using [RabbitMQ](https://www.rabbitmq.com/).

We'll build a small example with a producer that sends events and a consumer that receives them.
For testing, I'll run RabbitMQ in a Docker container (with the Management UI enabled so we can see what's happening).
We'll use the official [RabbitMQ.Client](https://www.nuget.org/packages/rabbitmq.client/) NuGet package in a .NET console app.

<div className='blockquote'>

Note: If you don't have RabbitMQ installed, you can run it quickly with Docker. For example:

```bash
docker run -it --rm --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:4-management
```

This starts a RabbitMQ broker on localhost (AMQP port `5672`) and a management website at `http://localhost:15672`.

</div>

## RabbitMQ Basics

Before coding, let's cover the basic components in RabbitMQ:

- **Producer**: an application that sends messages (events) to RabbitMQ.
- **Consumer**: an application that receives messages from a queue.
- **Queue**: a mailbox inside RabbitMQ that stores messages.
  Consumers read from queues.
  Many producers can send to the same queue.
- **Exchange**: a routing mechanism that receives messages from producers and directs them to queues.
  Producers actually send to an exchange instead of directly to a queue.
  This decouples producers from specific queues - the exchange can decide where messages go, based on rules.

In RabbitMQ, you can have multiple producers and multiple consumers.
Producers never send directly to a queue by name; instead, they send to an exchange.
The exchange decides which queues (if any) should get each message based on routing rules.

For now, we'll use a simple setup where the exchange will deliver all messages to one queue.

## Producer - Sending Events

Let's start with the producer.
In our .NET console app, we'll use RabbitMQ.Client to connect to the RabbitMQ broker and send a message.

For instance, an `OrderPlaced` event could trigger downstream services - inventory, email notifications, etc. -
without the ordering system needing to call them directly.

```csharp
var factory = new ConnectionFactory() { HostName = "localhost" };
using var connection = await factory.CreateConnectionAsync();
using var channel = await connection.CreateChannelAsync();

// Ensure the queue exists (create it if not already there)
await channel.QueueDeclareAsync(
    queue: "orders",
    durable: true, // save to disk so the queue isn’t lost on broker restart
    exclusive: false, // can be used by other connections
    autoDelete: false, // don’t delete when the last consumer disconnects
    arguments: null);

// Create a message
var orderPlaced = new OrderPlaced
{
     OrderId = Guid.NewGuid(),
     Total = 99.99,
     CreatedAt = DateTime.UtcNow
};
var message = JsonSerializer.Serialize(orderPlaced);
var body = Encoding.UTF8.GetBytes(message);

// Publish the message
await channel.BasicPublishAsync(
    exchange: string.Empty, // default exchange
    routingKey: "orders",
    mandatory: true, // fail if the message can’t be routed
    basicProperties: new BasicProperties { Persistent = true }, // message will be saved to disk
    body: body);

Console.WriteLine($"Sent: {message}");
```

This code connects to RabbitMQ on `localhost`, declares a queue named `orders` (creates it if it doesn't exist already),
and publishes an `OrderPlaced` message to that queue.
We use an empty string for the exchange parameter, which tells RabbitMQ to use the default exchange.
The default exchange routes the message directly to the `orders` queue.

What's happening here:

- We declare a **durable queue**, so it survives RabbitMQ restarts
- We mark the message as **persistent**, which tells RabbitMQ to write it to disk
- We serialize an object into JSON and send it as a UTF-8 encoded byte array

Now let's look at the consumer side.

## Consumer - Receiving Events

Next, let's set up a consumer to receive messages from the queue.
The consumer will also connect to RabbitMQ and subscribe to the same queue.

To test this out, start the consumer application first (it will wait for messages), then run the producer application to send an event.

```csharp
var factory = new ConnectionFactory() { HostName = "localhost" };
using var connection = await factory.CreateConnectionAsync();
using var channel = await connection.CreateChannelAsync();

// Declare (or check) the queue to consume from
await channel.QueueDeclareAsync(
    queue: "orders",
    durable: true, // must match the producer's queue settings
    exclusive: false, // can be used by other connections
    autoDelete: false, // don’t delete when the last consumer disconnects
    arguments: null);

// Define a consumer and start listening
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.ReceivedAsync += async (sender, eventArgs) =>
{
    byte[] body = eventArgs.Body.ToArray();
    string message = Encoding.UTF8.GetString(body);
    var orderPlaced = JsonSerializer.Deserialize<OrderPlaced>(message);

    Console.WriteLine($"Received: OrderPlaced - {orderPlaced.OrderId}");

    // Acknowledge the message
    await ((AsyncEventingBasicConsumer)sender)
        .Channel.BasicAckAsync(eventArgs.DeliveryTag, multiple: false);
};
await channel.BasicConsumeAsync("orders", autoAck: false, consumer);

Console.WriteLine("Waiting for messages...");
```

The consumer code declares the same `orders` queue and sets up an event handler for incoming messages.
We call `BasicConsumeAsync` to start listening on the queue.
RabbitMQ will push any new messages to our consumer's event handler.
Whenever a message arrives, the `consumer.ReceivedAsync` event fires, and we print out the message.

What's important here:

- `autoAck: false` ensures we only acknowledge messages we actually process
- If processing fails, we could use `BasicNack` to requeue or route to a dead-letter queue
- Deserializing into a strongly typed object makes it easy to reason about the event

So far we've had one consumer. But what if we run multiple consumers on the same queue?

## Competing Consumers - Scaling Out

What if you have multiple consumers for the same queue?
RabbitMQ allows **competing consumers** on a queue.

If two or more consumers listen on the same queue, each message from that queue will be delivered to **only one** of them:

- RabbitMQ will distribute messages among the consumers (roughly in round-robin order)
- This is great for scaling: you can run multiple instances of a worker to process messages in parallel

In other words, consumers _compete_ for messages on that queue.
This pattern helps spread the workload, but note that each individual message is still processed by a single consumer.

## Fanout Exchange: Broadcast to Multiple Consumers

Competing consumers share the work by dividing messages, but sometimes you want every service to get the event.
That's where a **fanout exchange** comes in.

In RabbitMQ, a fanout exchange is used for broadcasting events to multiple consumers.
Instead of all consumers sharing one queue, each consumer has its own queue.
When the producer sends a message to a fanout exchange, the exchange copies and routes the message to all bound queues.
This way, every consumer receives a copy via its own queue.

To set this up in code, we declare a fanout exchange and bind queues to it.

**Producer**:

```csharp
// Producer setup for fanout
await channel.ExchangeDeclareAsync(
    exchange: "orders",
    durable: true, // durable exchange
    autoDelete: false, // don’t delete when the last consumer disconnects
    type: ExchangeType.Fanout);

// Publish a message to the fanout exchange (routingKey is ignored for fanout)
var orderPlaced = new OrderPlaced
{
     OrderId = Guid.NewGuid(),
     Total = 99.99,
     CreatedAt = DateTime.UtcNow
};
var message = JsonSerializer.Serialize(orderPlaced);
var body = Encoding.UTF8.GetBytes(message);

await channel.BasicPublishAsync(
    exchange: "orders",
    routingKey: string.Empty,
    mandatory: true,
    basicProperties: new BasicProperties { Persistent = true },
    body: body);
```

**Consumer**:

```csharp
// Consumer setup for fanout
await channel.ExchangeDeclareAsync(
    exchange: "orders",
    durable: true,
    autoDelete: false,
    type: ExchangeType.Fanout);

// Create a queue for this consumer and bind it
await channel.QueueDeclareAsync(
    queue: "orders-consumer-1",
    durable: true,
    exclusive: false,
    autoDelete: false,
    arguments: null);

await channel.QueueBindAsync("orders-consumer-1", "orders", routingKey: string.Empty);

// Then consume messages from queueName as usual...
```

In the producer, we call `ExchangeDeclareAsync` to make sure an `orders` exchange exists (of type fanout).
We then `BasicPublishAsync` to that exchange.
For a fanout exchange, the `routingKey` can be an empty string because it's ignored (fanout sends to all queues regardless of any routing key).
On the consumer side, we declare the same exchange and then create a new `orders-consumer-1` queue.
We bind that queue to the `orders` exchange.
Now any message sent to the exchange will be delivered to this queue, and we can consume it.

If you run multiple consumer programs (each with its own queue bound to `orders` exchange),
each one will get every message (unlike the competing consumers scenario).
You can also peek into RabbitMQ's Management UI to see the exchange and queues in action.

<div className="centered">
  <Image
    src="blogs/mnw_140/rabbitmq_ui.png"
    width={818 * 0.75}
    height={889 * 0.75}
    alt="RabbitMQ Management UI"
  />
</div>

## Next Steps

You can expand this basic setup with more advanced RabbitMQ features.
For example, you might use a **direct exchange** or **topic exchange** to route events to specific services,
set up acknowledgment and retry policies for robustness,
or implement **dead-letter queues** for error handling.
The core idea throughout is the same: decouple senders and receivers with a message broker, making your system more flexible and resilient.

If you want to explore event-driven architecture further, including patterns like the ones we touched on (and beyond),
check out my [**Modular Monolith Architecture**](/modular-monolith-architecture) course.
It covers these concepts in depth with practical examples, so you can apply EDA in real-world projects.

Good luck out there, and see you next week.

---



<Sponsorships>

Did you know that there's a way to save thousands on your Microsoft Azure bills?
[**Archera**](https://fnf.dev/42QlPrr) turns cloud spend on its head with their **cloud commitment insurance.**
They help you commit to reserved instances with confidence and write you an actual check if you underutilize your commitments.
They also allow you to achieve more than the cost savings of native plans with a commitment as low as 30 days, instead of 1 to 3 years.
[**Check out how it works with this video**](https://fnf.dev/4iyBPE2).

[**Build Your Own Token Visualizer in .NET**](https://www.telerik.com/blogs/build-token-visualizer-dotnet?utm_medium=cpm&utm_source=milanjovanovich&utm_campaign=blazor-general-awareness).
Want to peek under the hood of how code gets parsed?
Learn how to use Roslyn to visualize tokens and better understand the structure of your C# code.
Whether you're building a code analyzer, working on an IDE extension, or just diving deeper into how your tools work under the hood,
this tutorial is packed with practical insights and clean, usable code examples.
[**Check it out**](https://www.telerik.com/blogs/build-token-visualizer-dotnet?utm_medium=cpm&utm_source=milanjovanovich&utm_campaign=blazor-general-awareness).

</Sponsorships>

When you're building a [**modular monolith**](what-is-a-modular-monolith), it's easy to let bounded contexts grow too large over time.
What started as a clean domain boundary slowly turns into a dumping ground for unrelated logic.
Before you know it, you have a massive context responsible for users, payments, notifications, and reporting - all tangled together.

This article is about tackling that mess.
We'll walk through how to identify an overgrown bounded context, and refactor it step-by-step into smaller, well-defined contexts.
You'll see practical techniques in action, with real .NET code and without theoretical fluff.

## Identifying an Overgrown Context

You know you have a problem when:

- You're afraid to touch code because everything is interconnected
- The same entity is used for 4 unrelated use cases
- You see classes with 1000+ lines or services that do too much
- Business logic from different subdomains bleeds into each other

Here's a classic example.

We start with a `BillingContext` that now handles everything from notifications to reporting:

```csharp
public class BillingService
{
    public void ChargeCustomer(int customerId, decimal amount) { ... }
    public void SendInvoice(int invoiceId) { ... }
    public void NotifyCustomer(int customerId, string message) { ... }
    public void GenerateMonthlyReport() { ... }
    public void DeactivateUserAccount(int userId) { ... }
}
```

This service has no clear boundaries.
It mixes **Billing**, **Notifications**, **Reporting**, and **User Management** into a single, bloated class.
Changing one feature could easily break another.

## Step 1: Identify Logical Subdomains

We start by breaking this apart logically.
Think like a product owner.

Just ask: "What domains are we really working with?"

Group the methods:

- **Billing**: `ChargeCustomer`, `SendInvoice`
- **Notifications**: `NotifyCustomer`
- **Reporting**: `GenerateMonthlyReport`
- **User Management**: `DeactivateUserAccount`

Code within a [**bounded context**](monolith-to-microservices-how-a-modular-monolith-helps) should model a coherent domain.
When multiple domains are jammed into the same context, your architecture becomes misleading.

You can validate these groupings by checking:

- Which parts of the system change together?
- Do teams use different vocabulary for each area?
- Would you give each domain to a different team?

If yes, it's a sign you're dealing with distinct contexts.

## Step 2: Extract One Context at a Time

Don't try to do it all at once.
Start with something low-risk.

Let's begin by extracting **Notifications**.

Why **Notifications**?
Because it's a pure side-effect.
It doesn't impact business state, so it's easier to decouple safely.

Create a new module and move the logic there:

```csharp
// New module: Notifications
public class NotificationService
{
    public void Send(int customerId, string message) { ... }
}
```

Then simplify the original `BillingService`:

```csharp
public class BillingService
{
    private readonly NotificationService _notificationService;

    public BillingService(NotificationService notificationService)
    {
        _notificationService = notificationService;
    }

    public void ChargeCustomer(int customerId, decimal amount)
    {
        // Charge logic...
        _notificationService.Send(customerId, $"You were charged ${amount}");
    }
}
```

This works. But now **Billing** _depends on_ **Notifications**.
That's a coupling we want to avoid long-term.

Why?
Because a failure in **Notifications** could block a billing operation.
It also means **Billing** can't evolve independently.

Let's decouple with [**domain events**](how-to-use-domain-events-to-build-loosely-coupled-systems):

```csharp {10,20-24}
public class CustomerChargedEvent
{
    public int CustomerId { get; init; }
    public decimal Amount { get; init; }
}

// Module: Billing
public class BillingService
{
    private readonly IDomainEventDispatcher _dispatcher;

    public BillingService(IDomainEventDispatcher dispatcher)
    {
        _dispatcher = dispatcher;
    }

    public void ChargeCustomer(int customerId, decimal amount)
    {
        // Charge logic...
        _dispatcher.Dispatch(new CustomerChargedEvent
        {
            CustomerId = customerId,
            Amount = amount
        });
    }
}

// Module: Notifications
public class CustomerChargedEventnHandler : IDomainEventHandler<CustomerChargedEvent>
{
    public Task Handle(CustomerChargedEvent @event)
    {
        // Send notification
    }
}
```

Now **Billing** doesn't even _know_ about **Notifications**.
That's real modularity.
You can replace, remove, or enhance the **Notifications** module without touching **Billing**.

## Step 3: Migrate Data (If Needed)

Most monoliths start with a single database.
That's fine.
But real modularity comes when each module controls its own [**schema**](modular-monolith-data-isolation).

Why?
Because the database structure reflects ownership.
If everything touches the same tables, it's hard to enforce boundaries.

You don't have to do it all at once.
Start with:

- Creating a [**separate `DbContext` per module**](using-multiple-ef-core-dbcontext-in-single-application)
- Gradually migrate the tables to their own schemas
- Read-only projections or database views for cross-context reads

```csharp
// Module: Billing
public class BillingDbContext : DbContext
{
    public DbSet<Invoice> Invoices { get; set; }
}

// Module: Notifications
public class NotificationsDbContext : DbContext
{
    public DbSet<NotificationLog> Logs { get; set; }
}
```

This separation enables independent schema evolution.
It also makes [**testing**](testing-modular-monoliths-system-integration-testing) faster and safer.

When migrating, use a transitional phase where both contexts read from the same underlying data.
Only switch write paths when confidence is high.

## Step 4: Repeat for Other Areas

Apply the same playbook.
Target a clean split per subdomain.

Next up: **Reporting** and **User Management**.

Before:

```csharp
billingService.GenerateMonthlyReport();
billingService.DeactivateUserAccount(userId);
```

After:

```csharp
reportingService.GenerateMonthlyReport();
userService.DeactivateUser(userId);
```

Or via events:

```csharp
_dispatcher.Dispatch(new MonthEndedEvent());
_dispatcher.Dispatch(new UserInactiveEvent(userId));
```

The goal here isn't just technical cleanliness - it's clarity.
Anyone looking at your solution should know what each module is responsible for.

And remember: boundaries should be enforced by code, not just by folder structure.
Different projects, separate EF models, and [**explicit interfaces**](internal-vs-public-apis-in-modular-monoliths) help enforce the split.
[**Architecture tests**](enforcing-software-architecture-with-architecture-tests) can also help ensure that modules don't break their boundaries.

## Takeaway

Once you've finished the refactor, you'll have:

- **Smaller services** focused on one job
- **Decoupled modules** that evolve independently
- **Better tests** and easier debugging
- **Bounded contexts** that actually match the domain

This is more than structure, it's design that supports change.
You get loose coupling, testability, and clearer mental models.

You don't need microservices to get modularity.
You need to treat your monolith like a set of cooperating, isolated parts.

Start with one module.
Ship the change.
Repeat.

Want to go deeper into modular monolith design?
My full video course, [**Modular Monolith Architecture**](/modular-monolith-architecture),
walks you through building a real-world system from scratch - with clear boundaries, isolated modules, and practical patterns that scale.
Join 1,800+ students and start building better systems today.

That's all for today.

See you next Saturday.

---



<Sponsorships>

[**Build Faster with ABP.IO Modules**](https://abp.io/modules?utm_source=newsletter&utm_medium=affiliate&utm_campaign=milanjovanovic_apr19).
Save weeks of development time with ready-made, enterprise-grade modules from ABP.IO.
From Identity and SaaS to Audit Logging and Language Management, ABP's modular architecture helps you ship faster and scale confidently — all within your favorite .NET ecosystem.
Each module is fully integrated, tested, and production-ready — so you can focus on building what makes your web app unique.
➡️ [**Explore the full list**](https://abp.io/modules?utm_source=newsletter&utm_medium=affiliate&utm_campaign=milanjovanovic_apr19)!

A great auth product gets out of your way.
[**PropelAuth**](https://www.propelauth.com/?utm_source=newsletter&utm_campaign=mj)
makes it easy to [**add authentication to your .NET application**](https://docs.propelauth.com/guides-and-examples/guides/dot-net-oauth-guide/?utm_source=newsletter&utm_campaign=mj) -
no digging through obscure documentation or frantically searching StackOverflow for answers.
Whether you're supporting small businesses or huge enterprises, PropelAuth has everything you need: organization management, RBAC, MFA, Enterprise SSO and more.

</Sponsorships>

I've been revisiting Sam Newman's excellent book ["Monolith to Microservices"](https://www.oreilly.com/library/view/monolith-to-microservices/9781492047834/) recently,
and it's reminded me just how transformative this architectural approach can be **when applied correctly**.

As someone who's implemented microservices in various organizations, I wanted to share some valuable insights I've gained through both study and practical experience.

What exactly are microservices, and why might they be the right architectural choice for your organization?

Let's dive into the core concepts and benefits of microservices architecture.

## What Are Microservices?

Microservices are **independently deployable** services modeled around a **business domain**.
Business domain is key here, but more on that later.
They communicate with each other via networks and offer many options for solving complex architectural problems.

Think of microservices as small, focused teams rather than a large department.
Each team has a specific responsibility, operates somewhat independently, and communicates clearly with other teams when needed.
Instead of one massive codebase that handles everything, you have multiple smaller codebases, each focusing on a specific business capability.

<Image
  src="blogs/mnw_138/microservices_architecture.png"
  width={2115}
  height={1591}
  alt="Microservices architecture showing an event management system."
/>

As Sam Newman defines them in "Monolith to Microservices":

> Microservices are independently deployable services modeled around a business domain.
> They communicate with each other via networks, and as an architecture choice offer many options for solving the problems you may face.

Microservices give you a strategy to design a modular system and decompose it into bounded contexts.
However, the problem I often see is that developers use microservices to enforce code boundaries.
This is a mistake.
We'll fix that in a moment.

## Key Characteristics of Microservices

Let's explore some of the key characteristics that define microservices:

### Independent Deployability

You can make changes to a microservice and deploy it to production without having to deploy anything else.
This isn't just a theoretical ability - it's a discipline you practice for most of your releases.

The value here is significant: **smaller deployments** carry **less risk**, enable **faster release cycles**, and allow teams to test their changes in isolation.

When a critical bug appears in one service, you can fix and deploy just that service rather than orchestrating a full system release.
This is especially valuable in large systems where coordinating releases can be a logistical nightmare.

### Business Domain Focus

Microservices are organized around [**business capabilities**](screaming-architecture) rather than technical layers.
Instead of having separate frontend, backend, and database teams (and the coordination that requires),
you might have teams dedicated to "Event Management," "Customer Accounts," or "Attendance."

This alignment makes it easier to implement business functionality changes since all the related code - from UI to data storage - is grouped together.
When a business requirement changes, you can often change just one service rather than coordinating changes across multiple layers.

<Image
  src="blogs/mnw_138/event_storming.png"
  width={2534}
  height={876}
  alt="Event storming whiteboard with events grouped into logical boundaries."
/>

### Data Ownership

Microservices **encapsulate data storage** and retrieval, exposing data only via [**well-defined interfaces**](internal-vs-public-apis-in-modular-monoliths).
Databases are hidden inside the service boundary rather than shared between services.

This stands in stark contrast to traditional approaches where multiple applications share a common database, often leading to tight coupling and risky schema changes.

When a service owns its data exclusively, it can:

- Evolve its internal data model without breaking other services
- Implement the most appropriate storage technology for its needs
- Provide a stable API for other services to access its data.

It's not uncommon for multiple services to share the same database, but you're giving up some of the benefits of microservices by doing so.
In practice, one database per service is the most common approach.

### Network Communication

Services communicate with each other via networks, making microservices a form of distributed system.
This network-based communication could use [**REST APIs**](/pragmatic-rest-apis), message queues, gRPC, GraphQL, or other protocols depending on the specific needs.

<div className="centered">
  <Image
    src="blogs/mnw_138/network_communication.png"
    width={736 * 0.7}
    height={372 * 0.7}
    alt="A simple diagram with two boxes representing microservices that communicate over a network."
  />
</div>

This explicit communication over networks allows services to be deployed independently and even run on different infrastructure.
But it also means dealing with network latency, potential failures, and serialization concerns.

Teams building microservices need to carefully design their [**inter-service communication patterns**](modular-monolith-communication-patterns)
to balance performance, reliability, and flexibility.

## The Origins of Microservices

The term "microservices" has an interesting origin story.
In 2011, a software consultant named James Lewis became interested in what he called "micro-apps" - small services optimized to be easily replaceable.

The distinguishing feature was how small in scope these services were.
Some could be written or rewritten in just a few days.
As discussions evolved, the term "microservices" was adopted since these weren't self-contained applications but rather services working together.

It's worth noting that while "micro" is in the name, the size of a microservice isn't its defining characteristic.
Rather, it's about having services with well-defined boundaries that can be developed, deployed, and scaled independently.

## Key Benefits of Microservices

What are the benefits of adopting a microservices architecture?

Why should you consider it for your organization?

Let's explore some of the key advantages:

### Flexibility and Adaptability

**Microservices give you options**.
They provide flexibility in how you can scale, evolve, and maintain your system over time.

- When business requirements change, you can modify just the affected services rather than risking changes to the entire system.
- New capabilities can be introduced as new services without disrupting existing functionality.
- As your understanding of the domain grows, service boundaries can evolve to better reflect that understanding.

This ability to evolve incrementally is particularly valuable in rapidly changing business environments where time-to-market is critical.

### Technology Diversity

With microservices, you can mix and match technology stacks.
Each service can use the programming language, database, or framework best suited for its specific requirements.
This practice is known as polyglot programming and [**polyglot persistence**](modular-monolith-data-isolation).

For example, a recommendation engine might use Python with specialized machine learning libraries.
On the other hand, a transaction processing service might use .NET for its strong typing and performance characteristics.

A reporting service might use a columnar database optimized for analytics,
while a user profile service could use a document database that better fits its data model.

<div className="centered">
  <Image
    src="blogs/mnw_138/polyglot_persistence.png"
    width={639 * 0.5}
    height={746 * 0.5}
    alt="Event storming whiteboard with events grouped into logical boundaries."
  />
</div>

This flexibility allows teams to choose the right tool for each job rather than compromising on a one-size-fits-all approach.

### Parallel Development

Multiple teams can work on different services simultaneously without stepping on each other's toes.
This parallelization can significantly accelerate development velocity in larger organizations.

Each team can maintain its own release schedule, make technology decisions, and optimize for their specific service's needs without coordinating with every other team.
I've seen firsthand how this autonomy can reduce dependencies between teams, minimizing bottlenecks and wait times.

Organizations commonly structure their teams around services or groups of related services.
You might know this concept as [Conway's Law](https://en.wikipedia.org/wiki/Conway%27s_law):

> Organizations, who design systems, are constrained to produce designs which are copies of the communication structures of these organizations.

### Targeted Scaling

You can scale just the services that need it, rather than scaling the entire system.
This provides more efficient resource utilization and can reduce operational costs.

For example, if your product catalog needs to handle high traffic during a sale, you can scale just the catalog service without scaling your payment processing service.

This granular scaling becomes especially valuable as systems grow and different components have different performance characteristics.
Some services might be CPU-intensive while others are memory-intensive, and with microservices, you can optimize the infrastructure for each service's specific needs.

This approach can lead to significant cost savings compared to [**scaling a monolith**](scaling-monoliths-a-practical-guide-for-growing-systems),
where all components must scale together regardless of their individual requirements.

### Organizational Alignment

Microservices can help align your technical architecture with your organizational structure.
Teams can own specific services that correspond to their business domain expertise, promoting clearer ownership and accountability.

<div className="centered">
  <Image
    src="blogs/mnw_138/evently_domain.png"
    width={2506 * 0.25}
    height={1282 * 0.25}
    alt="UML diagram showing the main bounded contexts in the system and their parts."
  />
</div>

This alignment reduces handoffs and coordination costs between teams, as each team has clear boundaries of responsibility.
It supports Conway's Law in a positive way.
Instead of having your communication structure accidentally create your architecture, you deliberately design both your teams and your services around business capabilities.

This approach can lead to more stable team structures and software boundaries over time, as business domains tend to evolve more slowly than technical implementations.

## Challenges to Consider With Microservices

While microservices offer numerous benefits, they're not without challenges:

### Distributed System Complexity

Network communication introduces latency, reliability challenges, and makes debugging more difficult.
Services must handle network failures gracefully, implement retries with backoff strategies,
and deal with the reality that a request might succeed but the response might get lost.

[**Distributed tracing**](introduction-to-distributed-tracing-with-opentelemetry-in-dotnet) becomes essential to understand how requests flow through the system.

<Image
  src="blogs/mnw_138/distributed_trace.png"
  width={1920}
  height={850}
  alt="Distributed trace."
/>

You'll need to develop strategies for handling partial system failures.
Concepts like circuit breakers and bulkheads become part of your everyday vocabulary.

### Operational Overhead

Managing many services requires robust [**deployment pipelines**](streamlining-dotnet-9-deployment-with-github-actions-and-azure), monitoring, and debugging tools.
You'll need to invest in automation for deployment, [**health checking**](health-checks-in-asp-net-core), scaling,
and perhaps [**service discovery**](how-dotnet-aspire-simplifies-service-discovery).
Each service needs monitoring, logging, and alerting.

This overhead can be substantial.
Organizations successfully running microservices typically have a strong DevOps culture and tooling to manage this complexity.

### Data Consistency

Maintaining consistency across service boundaries becomes more challenging without the safety of [**database transactions**](working-with-transactions-in-ef-core).

Implementing business processes that span multiple services often requires eventual consistency models and compensation mechanisms to handle failures.
You'll need to design your services with [**idempotency**](implementing-idempotent-rest-apis-in-aspnetcore) in mind and may need to implement patterns like the
[**Saga pattern**](implementing-the-saga-pattern-with-masstransit) to manage distributed transactions.

These approaches add complexity but can actually lead to more resilient systems when implemented correctly.

### Service Coordination

Orchestrating workflows that span multiple services requires careful design.
Simple processes in a monolith can become complex choreographies in a microservice architecture.

You'll need to decide whether to use [**orchestration**](orchestration-vs-choreography) (where a central service directs the process)
or [**choreography**](orchestration-vs-choreography) (where services react to events without central coordination).
These patterns have different trade-offs in terms of coupling, resilience, and observability.

Designing these cross-service workflows often reveals subdomain boundaries you might have missed in initial modeling.

## Key Takeaway

From my experience, the most important thing to remember is that microservices ultimately **buy you options**.
They provide flexibility but come with costs.

Are these costs worth the options you want to exercise?

For organizations with a large engineering team working on a complex system that needs to evolve quickly, microservices may be worth the overhead.
For smaller teams or systems with more stable requirements, a [**well-designed monolith**](what-is-a-modular-monolith) might be more appropriate.
Forget about resume-driven development for a moment.
It's about what solves your specific problems with **acceptable trade-offs**.

In my work, I've found that the most successful microservice adoptions start small, often by breaking off just one or two services from a monolith.
Then, gradually expanding as the organization builds the necessary skills and infrastructure.
This evolutionary approach reduces risk and allows teams to learn as they go.

I always like to reflect on these questions:

1. What parts of the current architecture would benefit most from independent deployability?
2. What challenges might the organization face when adopting microservices?
3. How well does the current system align with business domains?

If you want to dive deeper into building microservices - but starting from a monolith, check out [**Modular Monolith Architecture**](/modular-monolith-architecture).
There's an entire chapter dedicated to developing microservices, including advanced techniques such as API gateways, using message queues, and system integration testing.

Thanks for reading.

And stay awesome!

---



<Sponsorships>

Developers must start adopting AI in their daily workflow to be competitive,
which is why Dometrain just launched a [**Deep Dive into Boosting Developer Productivity with AI**](https://dometrain.com/course/deep-dive-boosting-developer-productivity-with-ai/?ref=milan-jovanovic&promo=newsletter-20250412&coupon_code=BIRTHDAY2).
From Claude Sonnet to GPT4o and from ChatGPT to any IDE, this new Dometrain course will ensure your productivity and competitiveness in the market.
Use code BIRTHDAY2 at checkout for 40% off.
[**Get it at 40% off**](https://dometrain.com/course/deep-dive-boosting-developer-productivity-with-ai/?ref=milan-jovanovic&promo=newsletter-20250412&coupon_code=BIRTHDAY2)!

[**Hey .NET devs, can your AI Agent do this**](https://fnf.dev/4hzFtNz)?

- Add new features spanning multiple files
- Queue up tests for you in the terminal
- Open Linear tickets, start a pull request
- Start a new branch in GitHub from recent commits

Augment Code's new AI Agent can. [**Try it in VS Code now**](https://fnf.dev/4hzFtNz)!

</Sponsorships>

**Vector search** is changing how we find information.
Unlike old search methods that look for exact words, vector search finds content based on meaning.
This makes search results more helpful and human-like.

When you search for "quick healthy breakfast ideas," vector search can find articles about "nutritious morning meals" even if they don't use your exact words.
This happens because vector search understands what you mean, not just what you type.

In this week's newsletter, we'll break down how vector search works and why it's important.

## Understanding Vector Embeddings

At the heart of vector search are **vector embeddings**.
These are lists of numbers that represent data.
But how do we get from words or images to numbers?

Here's how it works:

1. We feed text, images, or other data into a [**large language model (LLM)**](working-with-llms-in-dotnet-using-microsoft-extensions-ai)
2. The LLM turns each piece of data into a list of numbers (a vector)
3. These numbers capture the meaning of the data
4. Similar things get similar number patterns

<div className="centered">
  <Image
    src="blogs/mnw_137/vector_space.png"
    width={1719 * 0.3}
    height={1937 * 0.3}
    alt="Vector space visualization."
  />
</div>

Think of each number in the vector as describing one aspect of the data.
With hundreds or thousands of these numbers, vectors can capture complex meanings and relationships.

For example, in vector form, the words "lion" and "bobcat" would have similar number patterns because they refer to similar animals.
Meanwhile, "cat" would have a different pattern, though still somewhat similar since it's also a feline.

## How Vector Search Works

When you search using vector search:

1. Your search question gets turned into a vector
2. The system compares this vector to all the vectors in its database
3. It finds the vectors that are most similar to your search vector
4. It returns the data connected to those similar vectors

To find similar vectors, the system measures how close they are to each other.
Think of each vector as a point in space - the closer two points are, the more similar their meanings.

<Image
  src="blogs/mnw_137/vector_search.png"
  width={2487}
  height={786}
  alt="Vector search visualization."
/>

### Vector Databases

To make vector search work well with lots of data, we need special storage systems called **vector databases**.
These databases are built to store and quickly search through millions or billions of vectors.

Vector databases do more than just store vectors - they organize them in smart ways that make searching faster.
They use special methods called "Approximate Nearest Neighbor" (ANN) algorithms that can find similar vectors without checking every single one in the database.

<figure className="figure-center">
  <div className="bordered">
    <Image
      src="blogs/mnw_137/vector_databases_landscape.png"
      width={1400}
      height={832}
      alt="Vector databases landscape."
    />
  </div>
  <figcaption>
    Source: [What are Vector Databases? A Beginner's
    Guide](https://www.infracloud.io/blogs/vector-databases-beginners-guide/)
  </figcaption>
</figure>

These databases also store the original content along with its vector, so when you get search results,
you see the actual text, images, or other data you were looking for.
Popular vector databases include Weaviate, Pinecone, and Qdrant.
But you can also turn PostgreSQL into a vector database using the pgvector extension.

The combination of vector embeddings and vector databases makes search extremely fast, even with millions of items to search through.
This speed makes vector search practical for real-world applications where users expect instant results.

## Key Differences from Traditional Search

Traditional keyword search works like this:

- You type "red shoes"
- The system finds pages with the words "red" and "shoes"
- Results that mention these words more often rank higher

This approach has problems:

- It misses related terms ("scarlet footwear")
- It doesn't understand context
- It can't handle questions well

An improvement to keyword search is [**full-text search**](how-i-implemented-full-text-search-on-my-website), which looks at the whole text of documents.
However, this still has some shortcomings that vector search solves.

Vector search fixes these issues by focusing on meaning rather than exact words.
It can:

- Find content with related concepts
- Understand the context of your search
- Return helpful results even for complex questions

This is why vector search powers many modern AI applications.
It helps chatbots find relevant information and makes recommendation systems more accurate.

## Summary

Vector search represents a major step forward in how computers understand and retrieve information.
By converting data into number patterns that capture meaning, vector search can find connections that keyword search would miss.

This technology is behind many of the smart search features we now take for granted -
from finding similar products in online stores to helping AI assistants answer our questions.
As AI continues to advance, vector search will play an increasingly important role in helping us navigate the growing sea of digital information.

While not perfect, vector search bridges the gap between how computers store data and how humans think about meaning -
making our digital tools more helpful and intuitive to use.

In a future newsletter, we'll dive into the practical side of vector search.
You'll learn how to implement your own vector search system using popular tools and libraries, with step-by-step code examples and best practices.

That's all for today.

See you next week.

---


Previous issues of The .NET Weekly