You’ve shipped APIs that felt fast at first—and fragile later. Clean Architecture fixes that.

Clean Architecture for C# APIs (NET 8) is a hands-on, story-driven guide. You’ll compare “quick MVC” to a Clean Architecture setup, then build a production-ready structure:

• Domain: entities, value objects, domain events
• Application: use cases, DTOs, CQRS with MediatR
• Infrastructure: EF Core persistence, repositories, third-party services
• Presentation: controllers or minimal APIs, mapping, validation, responses

Wire up Dependency Injection, add global exception middleware, structured logging (Serilog), and FluentValidation. Then test what matters: domain unit tests and integration tests across app/infra. Close with performance (caching, async I/O, DB isolation) and shipping (versioning, CI/CD, configuration, migrations).

You’ll learn to:

• Draw clear boundaries and invert dependencies
• Model domain logic without leaking EF/HTTP concerns
• Use MediatR/CQRS where it helps (and skip it where it doesn’t)
• Validate inputs, handle errors globally, log with context
• Write focused tests that prevent regressions
• Evolve safely with versioning and CI/CD

Built for junior–mid .NET engineers, teams refactoring legacy services, and anyone who wants code that stays easy to change.

Table of Contents (high level)

1. Intro to Clean Architecture
2. Traditional vs Clean
3. Core Principles (SoC, boundaries, DI)
4. Project Structure (Domain, Application, Infrastructure, Presentation)
5. Domain Layer
6. Application Layer (CQRS, MediatR)
7. Infrastructure (EF Core, repositories, external services)
8. Presentation (controllers/minimal APIs, validation, mapping)
9. Dependency Injection & lifetimes
10. Error Handling & Logging (middleware, Serilog, FluentValidation)
11. Testing (domain unit, integration for app/infra)
12. Refactoring & anti-patterns
13. Performance & scalability
14. Deploying & maintaining (versioning, CI/CD, config, migrations)

Ideal For

• .NET devs moving from “get it working” to “keep it working”
• Teams standardizing architecture across services