Microservices with DDD, CQRS and Clean Architecture using .NET 8

4 min readMar 25, 2024

We are going to develop Ordering Microservices implementing DDD, CQRS and Clean Architecture using ASP.NET Core, EF Core and SQL Server database.

Ordering Microservice with DDD, CQRS and Clean Architecture

I have just published course — .NET 8 Microservices: C# 12, DDD, CQRS, Vertical/Clean Architecture.

The Architectural Essence 🛠️

Peering into the internal mechanics, the Ordering Microservice is a symphony of modern practices and patterns:

Minimal APIs & .NET 8: Harnessing the simplicity and efficiency of ASP.NET Core Minimal APIs, complemented by the latest advancements in .NET 8 and C# 12.
Clean Architecture: A structured blueprint ensuring separation of concerns, with layers dedicated to Domain, Application, Infrastructure, and API.
DDD & CQRS: A strategic design approach with Domain-Driven Design at its heart, accompanied by the CQRS pattern for clear command-query segregation, orchestrated with the help of MediatR.

Domain Analysis of Ordering Microservices 📚

At the heart of the Ordering microservice, we have two pivotal entities: Order and OrderItem. Think of an Order as a basket of goodies (OrderItems) that a customer wishes to purchase. 🛍️

Order: This is your main basket, containing essentials like Customer ID, Order Name, Shipping Address, and the list of items (OrderItems) it holds.
OrderItem: These are the goodies! Each item details the product, its quantity, and price.

Plotting the Use Cases: The Order Lifecycle 🔄

When we talk about the operations our microservice can perform, it’s all about managing the lifecycle of an Order:

CRUD Operations: Create, Read, Update, and Delete orders. Simple yet powerful!
Order Fulfillment: This is where the magic happens! From processing payments to arranging shipments.
Basket Checkout Integration: Listening in on those checkout events from the Basket service, ready to swing into action.

The API Blueprint: Serving Orders on a Silver Platter 🍽️

Our Ordering microservice talks the RESTful language, making it super accessible and easy to integrate:

GET /orders: Peek into all orders, with a sprinkle of pagination.
POST /orders: Place a new order into the system.
PUT /orders: Need changes? No problem!
DELETE /order/{id}: Change your mind? We got you covered.

And for a bit of async magic, we’re tuning into Basket Checkout events, ensuring seamless order processing.

Under the Hood: SQL Server & EF Core 🛠️

The backbone of our Ordering microservice is the robust SQL Server, with EF Core as our trusty ORM sidekick. We’re all about embracing the Code-First approach, ensuring our domain intricacies beautifully translate into database schemas.

Application Architecture: DDD, CQRS, and Clean Architecture 🏛️

Our journey begins with embracing the principles of DDD (Domain-Driven Design), CQRS (Command Query Responsibility Segregation), and Clean Architecture.

These are the fundamental architectural styles guiding the development of the Ordering microservices. Clean Architecture implementation with creating 4 Layer with Class Library project that reference according to clean architecture.

Layer by Layer: The Clean Architecture 🏛️

Domain Core: At the heart lies the Domain layer, where the essence of our business logic resides — Entities, Value Objects, and Aggregates, all speaking the ubiquitous language of our domain.
Infrastructure Dynamics: The Infrastructure layer bridges our domain with the external world, leveraging EF Core 8 for seamless interaction with SQL Server, enriched with migrations, interceptors, and domain event dispatching.
Application Logic: The Application layer, where the CQRS strategy comes to life with MediatR, facilitating command handling, domain event processing, and validation with FluentValidation.
REST API Endpoints: The Ordering.API serves as the presentation layer, offering minimalist endpoints via Carter, robust exception handling, and vital health checks, ensuring our microservice is always at its best.

Wrapping Up: The Architectural Symphony 🎼

So there you have it, the domain analysis of our Ordering microservices, painting a picture of efficiency and robustness. With DDD, CQRS, and Clean Architecture guiding our path, we’re set to build a system that’s not just functional but a marvel in microservices design.