pos-system/docs/en/templates/dotnet-template.md

.NET 10 Microservice Template

Enterprise-grade .NET 10 microservice template following DDD, CQRS, and Clean Architecture patterns.

Overview

This template provides a production-ready structure for .NET microservices based on the eShopOnContainers reference architecture with:

• Domain-Driven Design (DDD) - Aggregates, Entities, Value Objects, Domain Events
• CQRS Pattern - Separate Commands (write) and Queries (read) with MediatR
• Clean Architecture - Domain, Infrastructure, API layered separation
• EF Core 10 - PostgreSQL with connection resilience
• FluentValidation - Request validation
• API Versioning - URL segment versioning
• Health Checks - Kubernetes-ready probes
• Structured Logging - Serilog with console and Seq

Prerequisites

Requirement	Version
.NET SDK	10.0.101+
Docker	24.0+
PostgreSQL	15+ (or use Docker)

Quick Start

1. Create New Service

# Copy template to new service
cp -r services/_template_dot_net services/your-service-name
cd services/your-service-name

# Rename all occurrences of "MyService" to "YourService"
find . -type f -name "*.cs" -exec sed -i '' 's/MyService/YourService/g' {} +
find . -type f -name "*.csproj" -exec sed -i '' 's/MyService/YourService/g' {} +

2. Configure Environment

cp .env.example .env
nano .env

3. Run with Docker

docker-compose up -d
docker-compose logs -f myservice-api

4. Run Locally

dotnet restore
dotnet build
dotnet run --project src/MyService.API

Project Structure

_template_dot_net/
├── src/
│   ├── MyService.API/              # Presentation Layer (Controllers, CQRS)
│   │   ├── Controllers/            # API endpoints
│   │   ├── Application/            # CQRS Implementation
│   │   │   ├── Commands/           # Write operations (MediatR)
│   │   │   ├── Queries/            # Read operations
│   │   │   ├── Behaviors/          # MediatR pipeline behaviors
│   │   │   └── Validations/        # FluentValidation validators
│   │   └── Program.cs              # Application entry point
│   │
│   ├── MyService.Domain/           # Domain Layer (Pure business logic)
│   │   ├── AggregatesModel/        # Aggregate roots and entities
│   │   ├── Events/                 # Domain events
│   │   ├── Exceptions/             # Domain exceptions
│   │   └── SeedWork/               # Base classes
│   │
│   └── MyService.Infrastructure/   # Infrastructure Layer
│       ├── EntityConfigurations/   # EF Core configurations
│       ├── Repositories/           # Repository implementations
│       └── MyServiceContext.cs     # DbContext with Unit of Work
│
├── tests/
│   ├── MyService.UnitTests/        # Unit tests
│   └── MyService.FunctionalTests/  # Integration tests
│
├── Dockerfile                      # Multi-stage Docker build
└── docker-compose.yml              # Local development setup

Architecture

graph TB
    subgraph "API Layer"
        C[Controllers]
        CMD[Commands]
        Q[Queries]
        B[Behaviors]
        V[Validations]
    end
    
    subgraph "Domain Layer"
        AR[Aggregate Roots]
        E[Entities]
        VO[Value Objects]
        DE[Domain Events]
    end
    
    subgraph "Infrastructure Layer"
        DB[(PostgreSQL)]
        R[Repositories]
        CTX[DbContext]
    end
    
    C --> CMD
    C --> Q
    CMD --> B --> V
    CMD --> AR
    Q --> R
    R --> CTX --> DB
    
    style C fill:#4a90d9,stroke:#2d5986,color:#fff
    style AR fill:#50c878,stroke:#2d8659,color:#fff
    style DB fill:#ff6b6b,stroke:#c0392b,color:#fff

Layer Responsibilities

1. Domain Layer

• ZERO external dependencies (except MediatR.Contracts)
• Contains only POCO classes
• Implements DDD tactical patterns

Component	Purpose
SeedWork	Base classes: Entity, ValueObject, IAggregateRoot
AggregatesModel	Aggregate roots with entities and value objects
Events	Domain events for cross-aggregate communication
Exceptions	Domain-specific exceptions

2. Infrastructure Layer

• Database access (EF Core)
• Repository implementations
• External service integrations

3. API Layer

• Controllers for HTTP handling
• Commands for write operations
• Queries for read operations
• MediatR behaviors for cross-cutting concerns

CQRS Pattern

Commands (Write Operations)

public record CreateSampleCommand(string Name, string? Description) 
    : IRequest<CreateSampleCommandResult>;

public class CreateSampleCommandHandler : IRequestHandler<CreateSampleCommand, CreateSampleCommandResult>
{
    public async Task<CreateSampleCommandResult> Handle(CreateSampleCommand request, CancellationToken ct)
    {
        var sample = new Sample(request.Name, request.Description);
        _repository.Add(sample);
        await _repository.UnitOfWork.SaveEntitiesAsync(ct);
        return new CreateSampleCommandResult(sample.Id);
    }
}

MediatR Pipeline

Request → LoggingBehavior → ValidatorBehavior → TransactionBehavior → Handler → Response

API Endpoints

Method	Endpoint	Description
GET	/api/v1/samples	Get all samples
GET	/api/v1/samples/{id}	Get sample by ID
POST	/api/v1/samples	Create new sample
PUT	/api/v1/samples/{id}	Update sample
DELETE	/api/v1/samples/{id}	Delete sample
PATCH	/api/v1/samples/{id}/status	Change status

Health Endpoints

Endpoint	Purpose
/health	Full health status
/health/live	Liveness probe
/health/ready	Readiness probe

Environment Variables

Variable	Description	Default
ASPNETCORE_ENVIRONMENT	Environment name	Development
DATABASE_URL	PostgreSQL connection	-
REDIS_URL	Redis connection	-
JWT_SECRET	JWT signing secret	-

Testing

# Run all tests
dotnet test

# Run with coverage
dotnet test /p:CollectCoverage=true /p:CoverageReportFormat=cobertura

# Run specific test project
dotnet test tests/MyService.UnitTests

Deployment

Docker Build

docker build -t myservice:latest .
docker run -p 5000:8080 --env-file .env myservice:latest

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myservice-api
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: api
        image: myservice:latest
        livenessProbe:
          httpGet:
            path: /health/live
            port: 8080
        readinessProbe:
          httpGet:
            path: /health/ready
            port: 8080

What's New in .NET 10

• C# 14 language features
• Improved Native AOT support
• Better async/await performance
• Enhanced JSON serialization
• 3-year LTS support (until November 2028)

Related Documentation

• Architecture Details
• DDD Patterns
• Deployment Guide

Resources

• eShopOnContainers
• .NET 10 Documentation
• MediatR
• FluentValidation