Clean Architecture Series

This series of articles provides an in-depth understanding of the architecture and implementation details of this project. Each article focuses on a specific aspect of the Clean Architecture principles applied in this solution.

Article Series (Ctrl+Click or Cmd+Click to open in a new tab)

  1. Clean Architecture: Introduction to the Project Structure
    • Overview of architectural layers and their roles
    • How responsibilities are separated in the solution
  2. Clean Architecture: Implementing AutoMapper for DTO Mapping with Audit Details
    • Setting up AutoMapper for data transformation
    • Incorporating audit trails in mapping profiles
  3. Clean Architecture: Validating Inputs with FluentValidation
    • Implementing clean input validation
    • Using FluentValidation in the API layer
  4. Clean Architecture: Dependency Injection Setup Across Layers
    • Configuring dependency injection for better modularity
    • Managing service lifetimes across architectural boundaries
  5. Clean Architecture: Implementing Activity Logging with Custom Attributes
    • Building a custom attribute system for activity tracking
    • Monitoring user actions throughout the application
  6. Clean Architecture: Handling Authorization and Role-Based Access Control (RBAC)
    • Setting up robust authorization
    • Implementing role-based access control
  7. Clean Architecture: The Unit of Work Pattern and Transaction Management Using Dapper
    • Implementing reliable transaction management
    • Coordinating database operations with Unit of Work
  8. Clean Architecture: Using Dapper for Data Access with the Repository Pattern
    • Implementing efficient data access patterns
    • Performance considerations with Dapper
  9. Clean Architecture: Best Practices for Creating and Using DTOs in the API
    • Designing and implementing effective DTOs
    • Mapping strategies between domain entities and DTOs
  10. Clean Architecture: Seeding Initial Data Using Docker Compose and SQL Scripts
    • Setting up automated data seeding
    • Managing database initialization
  11. Dockerizing the .NET Core API and PostgreSQL Server
    • Creating a containerized development environment
    • Docker setup for both development and production
  12. Error Handling and Exception Management in the API
    • Building a robust error handling system
    • Standardizing error responses

Further Reading

For more in-depth understanding of Clean Architecture principles: