Author: Abhishek Nag

As modern enterprise applications scale in size and complexity, maintaining a clean, modular architecture becomes critical. Traditional layered designs often fall short when performance, scalability, and clear separation of concerns are required.

That’s where implementing CQRS and MediatR in ASP.NET Core can transform your software architecture—offering a highly testable, loosely coupled, and maintainable approach. 

In this blog, we’ll walk you through the process of applying the CQRS pattern with MediatR in an ASP.NET Core project, explore real-world design principles, and share practical tips tailored for teams building enterprise-grade applications. 

🔍 What is CQRS in ASP.NET Core? 

CQRS (Command Query Responsibility Segregation) is a design pattern that separates read operations from write operations. In large applications, this segregation can lead to improved performance, scalability, and maintainability. 

• Command – Alters the state of the application (e.g., CreateOrder, UpdateCustomer). 

• Query – Retrieves data without changing the system state (e.g., GetOrderById, ListCustomers). 

🔑 Benefits of CQRS in ASP.NET Core: 

• Read and write operations scale independently. 

• Business logic is easier to reason about. 

• Read models can be optimized separately from write models. 

🧩 How MediatR Complements CQRS 

MediatR is a popular .NET library that implements the Mediator design pattern, helping you decouple the sender of a request from its handler. Instead of invoking services directly, you send commands and queries via IMediator. 

csharp 

CopyEdit 

// Traditional service call 
_orderService.CreateOrder(cmd); 
 
// With MediatR 
await _mediator.Send(cmd); 
 

Using MediatR in ASP.NET Core supports a clean separation of concerns, eliminates tight coupling, and promotes better testability—key advantages for enterprise software systems. 

📁 CQRS + MediatR Project Structure in ASP.NET Core 

Let’s say we are building an Order Management System. A modular folder structure may look like this: 

markdown 

CopyEdit 

/Features 
 /Orders 
   – CreateOrderCommand.cs 
   – CreateOrderHandler.cs 
   – GetOrderByIdQuery.cs 
   – GetOrderByIdHandler.cs 
 

🧰 Tech Stack: 

• ASP.NET Core 8 

• Entity Framework Core 

• MediatR 

• FluentValidation 

🚀 Setting Up ASP.NET Core with MediatR and FluentValidation 

First, install the required NuGet packages: 

bash 

CopyEdit 

dotnet add package MediatR.Extensions.Microsoft.DependencyInjection 
dotnet add package FluentValidation 
 

Then, configure Program.cs: 

csharp 

CopyEdit 

builder.Services.AddMediatR(cfg => 
   cfg.RegisterServicesFromAssembly(typeof(Program).Assembly)); 
builder.Services.AddValidatorsFromAssembly(typeof(Program).Assembly); 
 

This setup allows your commands and queries to be routed and validated without cluttering your controllers. 

🧾 Implementing a Command: CreateOrder 

CreateOrderCommand.cs 

csharp 

CopyEdit 

public record CreateOrderCommand(string CustomerName, List<string> Items) : IRequest<Guid>; 
 

CreateOrderHandler.cs 

csharp 

CopyEdit 

public class CreateOrderHandler : IRequestHandler<CreateOrderCommand, Guid> 
{ 
   private readonly AppDbContext _db; 
 
   public CreateOrderHandler(AppDbContext db) 
   { 
       _db = db; 
   } 
 
   public async Task<Guid> Handle(CreateOrderCommand request, CancellationToken cancellationToken) 
   { 
       var order = new Order 
       { 
           Id = Guid.NewGuid(), 
           CustomerName = request.CustomerName, 
           Items = string.Join(“,”, request.Items), 
           CreatedAt = DateTime.UtcNow 
       }; 
 
       _db.Orders.Add(order); 
       await _db.SaveChangesAsync(cancellationToken); 
 
       return order.Id; 
   } 
} 
 

Validation with FluentValidation 

csharp 

CopyEdit 

public class CreateOrderValidator : AbstractValidator<CreateOrderCommand> 
{ 
   public CreateOrderValidator() 
   { 
       RuleFor(x => x.CustomerName).NotEmpty(); 
       RuleFor(x => x.Items).NotEmpty().WithMessage(“Order must have at least one item.”); 
   } 
} 
 

🔎 Implementing a Query: GetOrderById 

GetOrderByIdQuery.cs 

csharp 

CopyEdit 

public record GetOrderByIdQuery(Guid OrderId) : IRequest<OrderDto>; 
 

GetOrderByIdHandler.cs 

csharp 

CopyEdit 

public class GetOrderByIdHandler : IRequestHandler<GetOrderByIdQuery, OrderDto> 
{ 
   private readonly AppDbContext _db; 
 
   public GetOrderByIdHandler(AppDbContext db) 
   { 
       _db = db; 
   } 
 
   public async Task<OrderDto> Handle(GetOrderByIdQuery request, CancellationToken cancellationToken) 
   { 
       var order = await _db.Orders.FindAsync(request.OrderId); 
       if (order == null) return null; 
 
       return new OrderDto 
       { 
           Id = order.Id, 
           CustomerName = order.CustomerName, 
           Items = order.Items.Split(‘,’).ToList(), 
           CreatedAt = order.CreatedAt 
       }; 
   } 
} 
 

🌐 Using CQRS and MediatR in ASP.NET Core Controllers 

csharp 

CopyEdit 

[ApiController] 
[Route(“api/[controller]”)] 
public class OrdersController : ControllerBase 
{ 
   private readonly IMediator _mediator; 
 
   public OrdersController(IMediator mediator) 
   { 
       _mediator = mediator; 
   } 
 
   [HttpPost] 
   public async Task<IActionResult> Create(CreateOrderCommand cmd) 
   { 
       var id = await _mediator.Send(cmd); 
       return CreatedAtAction(nameof(Get), new { id }, null); 
   } 
 
   [HttpGet(“{id}”)] 
   public async Task<IActionResult> Get(Guid id) 
   { 
       var order = await _mediator.Send(new GetOrderByIdQuery(id)); 
       return order == null ? NotFound() : Ok(order); 
   } 
} 
 

💡 Real-World Advantages of CQRS and MediatR in Enterprise Systems 

✅ Key Benefits: 

• Separation of concerns – Each handler focuses on a single responsibility. 

• Testability – Easier to write unit tests for individual handlers. 

• Scalability – Read operations can scale independently from writes. 

• Pipeline behaviors – Enables cross-cutting features like logging and transactions. 

⚠️ Common Pitfalls to Avoid: 

• Overuse in simple apps – CQRS may be unnecessary for basic CRUD operations. 

• Misaligned validation – Use centralized validators with FluentValidation. 

• Inconsistent boundaries – Know when and where to separate commands and queries. 

📌 When Should You Use CQRS and MediatR in ASP.NET Core? 

Ideal use cases: 

• Applications with complex business rules. 

• Scenarios where reads and writes have very different performance needs. 

• Teams seeking a decoupled architecture that supports scalability and DDD. 

Avoid it when: 

• Your app is a simple internal tool or admin dashboard. 

• Project timelines are tight and do not allow for architectural overhead. 

🏁 Conclusion: Implementing CQRS and MediatR in ASP.NET Core 

For enterprise-grade ASP.NET Core applications, implementing CQRS and MediatR brings structure, scalability, and testability to your software architecture. By clearly separating responsibilities, you empower your team to develop more robust, maintainable, and future-ready solutions. 

Whether you’re starting fresh or modernizing a legacy system, this pattern is worth considering for its ability to simplify complex logic and enhance long-term agility. 

Additional Resources: 

• How to Implement Blazor Error Handling in Blazor Server Apps?
• Why AI in Care Management Systems Is Essential for Modern Healthcare Providers?

n today’s digital economy, optimizing .NET applications for performance at scale is a business-critical necessity—not just a technical challenge.

Whether you’re building a SaaS platform, a microservices architecture, or a data-intensive enterprise system, delivering a high-performance .NET solution at scale requires much more than just upgrading to the latest framework version. 

From cloud-native workloads to modern enterprise applications, this guide dives deep into real-world lessons and actionable strategies for .NET performance optimization.

Designed for enterprise teams, startups, and CTOs seeking scalable .NET solutions, this is not a generic checklist—it’s a field-tested blueprint for success. 

1. Start with Data-Driven Profiling, Not Assumptions 

Performance tuning in .NET begins with measurement. Before making changes, understand what needs fixing. 

🔍 Key areas to investigate: 

• CPU and memory usage patterns 

• Latency in API endpoints 

• I/O bottlenecks and DB performance 

🛠️ Recommended Tools: 

• dotnet-trace, PerfView, JetBrains dotTrace 

• Application Insights, Datadog, or New Relic for APM 

• BenchmarkDotNet for code-level benchmarks 

💡 Even a 20ms delay in a high-traffic endpoint can cost hours of compute time each week. 

2. Architect for Scale, Not Just Simplicity 

To build scalable .NET applications, start with an architecture that supports growth. 

✔️ Choose the Right Hosting Model 

• REST APIs: ASP.NET Core + Kestrel, behind NGINX or YARP 

• Background jobs: Worker Services or Hangfire 

• Scalable deployment: Docker, Kubernetes, or Azure Container Apps 

✔️ Apply Clean Architecture Principles 

Separate concerns across: 

• Domain Layer (core logic) 

• Application Layer (use cases) 

• Infrastructure Layer (data access, external systems) 

• Presentation Layer (UI, APIs) 

This modular approach makes .NET performance optimization more manageable. 

3. Use Async/Await Smartly for High Performance 

Asynchronous programming is critical—but only when used correctly. 

✅ Best Practices: 

• Use ConfigureAwait(false) in libraries 

• Make DB, file, and network I/O operations async 

• Throttle concurrent operations with SemaphoreSlim 

🚫 Avoid: 

• Unnecessary async wrappers (Task.Run) for CPU-bound logic 

• Excessive parallelism without control 

⚙️ One enterprise reduced API latency by 40% just by cleaning up inefficient async patterns. 

4. Optimize Entity Framework Core for Scalability 

EF Core is convenient—but must be tuned like a database. 

📌 Performance Tuning Tips: 

• Use AsNoTracking() for read-only queries 

• Avoid N+1 problems with .Include() or explicit joins 

• Use indexes based on query usage, not just primary keys 

• Prefer compiled queries on hot paths 

• Fetch only needed fields—avoid SELECT * 

🏎️ For critical paths, consider Dapper for faster, low-overhead data access. 

5. Implement an Enterprise-Grade Caching Strategy 

Caching is non-negotiable in performance-focused .NET applications. 

🔒 Caching Layers: 

• In-Memory (IMemoryCache) 

• Distributed (IDistributedCache, Redis) 

• CDN and edge caching for APIs and static files (e.g., Cloudflare, Azure Front Door) 

🎯 Best Practices: 

• Apply per-user caching selectively 

• Use sensible expiration and cache invalidation 

• Leverage event-driven cache refresh with RabbitMQ or Azure Event Grid 

6. Optimize Threading and Parallelism in .NET 

Handling CPU-bound tasks efficiently can dramatically boost throughput. 

🧵 Use .NET primitives like: 

• Parallel.ForEach and Task Parallel Library (TPL) 

• System.Threading.Channels for producer-consumer models 

• Async streams for scalable iteration 

🚀 One scalable .NET application improved throughput by 3x by switching from naïve multi-threading to bounded channels. 

7. Reduce Memory Allocations and Garbage Collection Pressure 

.NET’s managed runtime doesn’t eliminate memory issues. 

⚠️ Common Issues to Watch: 

• Boxing value types 

• String concatenations (use StringBuilder) 

• Large object heap (LOH) fragmentation 

• Static references in DI containers 

🛠️ Monitoring Tools: 

• dotMemory, dotnet-gcdump, GC.GetTotalMemory() 

8. Backend Optimizations for API & Web Performance 

Frontend speed often depends on backend efficiency. 

🛠️ Optimize ASP.NET Core APIs: 

• Enable response compression (Brotli/Gzip) 

• Use Response Caching Middleware 

• Remove unnecessary middleware 

• Switch to Minimal APIs for stateless microservices 

💡 In a real-world deployment, switching to Minimal APIs on .NET 8 increased throughput by 20%. 

9. Log with Purpose, Not Noise 

Over-logging kills performance and increases cloud costs. 

✅ Logging Best Practices: 

• Use structured logging (Serilog, NLog) 

• Don’t log inside loops or high-frequency paths 

• Tune log levels per environment 

• Aggregate logs using Seq, Grafana, or Elastic Stack 

10. Use Native AOT and Cloud-Native Deployment Practices 

⚡ .NET 8 Native AOT: 

• Faster cold starts 

• Smaller memory footprint 

• Ideal for microservices or serverless functions 

🐳 Containerization: 

• Use Alpine-based images for size reduction 

• Avoid local disk writes—use volumes or blob storage 

• Target image sizes under 200MB 

☁️ Cloud Tips: 

• Use autoscaling in Azure App Services or Kubernetes 

• Perform synthetic load tests (e.g., Artillery, Azure Load Testing) 

• Monitor cold starts in Azure Functions 

11. Build a Performance-Driven Development Culture 

Great .NET scalability is a team effort, not a solo task. 

🧠 Best Practices for Teams: 

• Include performance reviews in pull requests 

• Enforce coding standards using SonarQube or CodeQL 

• Train engineers on non-functional requirements (NFRs) 

• Shift performance considerations to early design stages 

📣 Scalable software starts with developers thinking like product engineers. 

🔚 Conclusion: Real Performance Comes from Intentional Engineering 

Optimizing .NET applications for performance at scale requires a shift from reactive fixes to proactive architecture.

Whether it’s minimizing EF Core overhead, fine-tuning your caching strategy, or adopting cloud-native deployment pipelines, each layer plays a role in your system’s speed and scalability. 

For CTOs, engineering leaders, and technical architects building high-traffic systems, these performance best practices are not just optional—they’re foundational. 

Additional Resources: 

• Top Patterns and Performance Tips for Dependency Injection in ASP.NET Core
• Form Validation in Blazor Server: Best Practices for Enterprise Web Apps

As modern software architecture increasingly embraces microservices, performance and simplicity become vital.

Enter Minimal APIs in .NET 8—a powerful evolution in ASP.NET Core that enables developers to build high-performance, lightweight microservices with less boilerplate and faster startup times. 

Whether you’re an enterprise scaling services or a startup validating ideas quickly, Minimal APIs offer the agility and performance needed for today’s software systems. 

Why Use Minimal APIs in .NET 8 for Microservices? 

Traditional ASP.NET Core MVC comes with rich architectural patterns, but it often includes unnecessary overhead for small, focused services. Minimal APIs in .NET 8 strip away the layers—controllers, annotations, and extensive routing rules—resulting in: 

• Rapid bootstrapping and improved performance 

• Lower memory usage 

• Fewer files and less ceremony 

• Ideal compatibility with Docker, Kubernetes, and serverless 

For microservices that serve targeted responsibilities, Minimal APIs provide the flexibility and speed that larger frameworks may lack. 

Getting Started: Building a Microservice with Minimal APIs 

Let’s walk through building a simple catalog microservice using Minimal APIs in .NET 8. 

Step 1: Create a New Project 

bash 

CopyEdit 

dotnet new web -n CatalogService 
cd CatalogService 
 

This scaffolds a clean web project without controllers or views. 

Step 2: Add a Simple Endpoint 

Edit Program.cs: 

csharp 

CopyEdit 

var builder = WebApplication.CreateBuilder(args); 
var app = builder.Build(); 
 
app.MapGet(“/”, () => “Catalog Service is running!”); 
 
app.Run(); 
 

Then run the app: 

bash 

CopyEdit 

dotnet run 
 

And just like that, you have a running web API with a few lines of code. 

Creating CRUD Endpoints with Minimal APIs in .NET 8 

Let’s add basic product management (CRUD operations) for a product catalog. 

Model Definition 

csharp 

CopyEdit 

record Product(int Id, string Name, decimal Price); 
 

In-Memory Product Store 

csharp 

CopyEdit 

var products = new List<Product> 
{ 
   new Product(1, “Laptop”, 1099.99m), 
   new Product(2, “Keyboard”, 59.99m) 
}; 
 

Register CRUD Endpoints 

csharp 

CopyEdit 

app.MapGet(“/products”, () => products); 
 
app.MapGet(“/products/{id}”, (int id) => 
{ 
   var product = products.FirstOrDefault(p => p.Id == id); 
   return product is not null ? Results.Ok(product) : Results.NotFound(); 
}); 
 
app.MapPost(“/products”, (Product product) => 
{ 
   products.Add(product); 
   return Results.Created($”/products/{product.Id}”, product); 
}); 
 
app.MapPut(“/products/{id}”, (int id, Product updatedProduct) => 
{ 
   var index = products.FindIndex(p => p.Id == id); 
   if (index == -1) return Results.NotFound(); 
 
   products[index] = updatedProduct with { Id = id }; 
   return Results.Ok(updatedProduct); 
}); 
 
app.MapDelete(“/products/{id}”, (int id) => 
{ 
   var product = products.FirstOrDefault(p => p.Id == id); 
   if (product is null) return Results.NotFound(); 
 
   products.Remove(product); 
   return Results.Ok(); 
}); 
 

This setup gives you a working microservice using Minimal APIs in ASP.NET Core—without controllers, services, or added layers. 

Dependency Injection in Minimal APIs 

Even with its simplicity, Minimal APIs in .NET 8 still support essential architectural practices like dependency injection. 

Create a Service Interface and Implementation 

csharp 

CopyEdit 

public interface IProductService 
{ 
   IEnumerable<Product> GetAll(); 
} 
 
public class ProductService : IProductService 
{ 
   public IEnumerable<Product> GetAll() => new[] 
   { 
       new Product(1, “Monitor”, 199.99m), 
       new Product(2, “Mouse”, 29.99m) 
   }; 
} 
 

Register and Inject the Service 

csharp 

CopyEdit 

builder.Services.AddSingleton<IProductService, ProductService>(); 
 
app.MapGet(“/di-products”, (IProductService service) => 
{ 
   return Results.Ok(service.GetAll()); 
}); 
 

This keeps business logic modular and testable while preserving the minimalistic structure. 

Securing Minimal APIs in .NET 8 

Authentication and authorization are fully supported in the Minimal API model: 

csharp 

CopyEdit 

app.UseAuthentication(); 
app.UseAuthorization(); 
 
app.MapGet(“/secure-data”, [Authorize] () => “Secret Data”) 
  .RequireAuthorization(); 
 

You can also apply role-based access, policies, and JWT authentication—just like in traditional ASP.NET Core apps. 

Generating API Documentation with Swagger 

Documenting your API is simple with OpenAPI (Swagger) integration: 

Install Swagger 

bash 

CopyEdit 

dotnet add package Swashbuckle.AspNetCore 
 

Configure Swagger in Program.cs 

csharp 

CopyEdit 

builder.Services.AddEndpointsApiExplorer(); 
builder.Services.AddSwaggerGen(); 
 
if (app.Environment.IsDevelopment()) 
{ 
   app.UseSwagger(); 
   app.UseSwaggerUI(); 
} 
 

Swagger supports Minimal APIs with full parameter and response metadata, ideal for public-facing or internal APIs. 

Deploying .NET 8 Minimal APIs in Microservices Architecture 

These APIs are perfect for: 

• Serverless functions (e.g., Azure Functions, AWS Lambda) 

• Dockerized services in CI/CD pipelines 

• Kubernetes pods managed via Helm or Kustomize 

• Lightweight APIs behind API Gateways 

Example Dockerfile 

dockerfile 

CopyEdit 

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base 
WORKDIR /app 
 
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build 
WORKDIR /src 
COPY . . 
RUN dotnet publish -c Release -o /app/publish 
 
FROM base AS final 
COPY –from=build /app/publish . 
ENTRYPOINT [“dotnet”, “CatalogService.dll”] 
 

When Not to Use Minimal APIs 

While powerful, Minimal APIs in .NET 8 aren’t ideal for every use case. You might prefer MVC if: 

• Your team is heavily invested in layered architecture 

• The application requires advanced routing, filters, or model binding 

• You’re building a large-scale system with many developers 

Best Practices for Minimal APIs 

• Use route groups to organize endpoints 

• Avoid complex business logic in lambdas; delegate to services 

• Use record types or DTOs for clarity and immutability 

• Monitor performance for memory usage and cold-start behavior 

• Always document using Swagger for API visibility 

Conclusion 

Minimal APIs in .NET 8 offer a modern, clean, and highly efficient way to build microservices. They’re not just for beginners or quick prototypes—they’re production-ready, enterprise-friendly, and cloud-optimized. 

For startups aiming to ship fast, or enterprises scaling microservice-based platforms, Minimal APIs provide the flexibility and performance required in today’s fast-paced development environment. 

If you haven’t explored building microservices with Minimal APIs in .NET 8, now is the perfect time to start. The simplicity may surprise you—and the scalability will keep you going. 

Additional Resources: 

• Form Validation in Blazor Server: Best Practices for Enterprise Web Apps
• How to Implement Blazor Error Handling in Blazor Server Apps?