Clean Architecture in .NET Realworld Example

December 21, 2025 · 2936 words · 13 min read

Contents

Clean Architecture .NET Software Architecture SOLID Principles Domain-Driven Design

In the previous post, we took an overall look at Clean Architecture. In this article, let’s explore a real-world example of how to use Clean Architecture.

📚 Clean Architecture Series:
Clean Architecture in .NET Overall - Fundamentals and principles
Common Clean Architecture Mistakes - Learn what to avoid

💻 GitHub Repository

The complete source code for this implementation is available on GitHub:

🔗 Repository: DotNetCleanArchitecture

📦 What’s Included:

✅ Complete Product Management System implementation
✅ All layers: Domain, Application, Infrastructure, WebAPI
✅ CQRS pattern with Commands and Queries
✅ Repository Pattern and Unit of Work
✅ Entity Framework Core with InMemory database
✅ Domain Events implementation
✅ Value Objects (Money)
✅ REST API with Swagger documentation
✅ Unit tests and integration tests
✅ Docker support

Feel free to clone, explore, and experiment with the code!

🏗️ Real-World Implementation: Product Management System

Let’s walk through a complete implementation of a Product entity following Clean Architecture principles.

📊 System Overview

┌─────────────────────────────────────────────────────────┐
│                    Product Management System             │
│                                                          │
│  Features:                                              │
│  • Create Product with validation                       │
│  • Update Product details                               │
│  • Manage Stock (Add/Remove)                           │
│  • Activate/Deactivate Products                        │
│  • Query Products                                       │
└─────────────────────────────────────────────────────────┘

🎨 Architecture Diagram

┌───────────────────────────────────────────────────────────────┐
│                        WebAPI Layer                           │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │  ProductsController                                      │  │
│  │  ├── POST   /api/products        (Create)              │  │
│  │  ├── GET    /api/products        (GetAll)              │  │
│  │  ├── GET    /api/products/{id}   (GetById)             │  │
│  │  ├── PUT    /api/products/{id}   (Update)              │  │
│  │  └── DELETE /api/products/{id}   (Delete)              │  │
│  └─────────────────────────────────────────────────────────┘  │
│                          │                                     │
│                          │ HTTP Requests                       │
│                          ▼                                     │
├───────────────────────────────────────────────────────────────┤
│                     Application Layer                         │
│  ┌──────────────────────┐      ┌──────────────────────┐      │
│  │   Commands (Write)   │      │   Queries (Read)     │      │
│  │  ┌─────────────────┐ │      │  ┌─────────────────┐ │      │
│  │  │ CreateProduct   │ │      │  │ GetAllProducts  │ │      │
│  │  │ UpdateProduct   │ │      │  │ GetProductById  │ │      │
│  │  │ DeleteProduct   │ │      │  └─────────────────┘ │      │
│  │  └─────────────────┘ │      └──────────────────────┘      │
│  └──────────────────────┘                                     │
│           │                              │                     │
│           │ Uses Domain                  │ Uses Repository    │
│           ▼                              ▼                     │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │  Interfaces (Contracts)                                  │  │
│  │  • IProductRepository                                    │  │
│  │  • IUnitOfWork                                           │  │
│  └─────────────────────────────────────────────────────────┘  │
│                          ▲                                     │
├──────────────────────────┼─────────────────────────────────────┤
│                          │                                     │
│                     Domain Layer                              │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │  Product (Aggregate Root)                               │  │
│  │  ├── Properties: Id, Name, SKU, Price, Stock           │  │
│  │  ├── Methods:                                           │  │
│  │  │   • Create() ← Factory Method                        │  │
│  │  │   • UpdateDetails()                                  │  │
│  │  │   • AddStock() / RemoveStock()                       │  │
│  │  │   • Activate() / Deactivate()                        │  │
│  │  └── Domain Events:                                     │  │
│  │      • ProductCreated                                   │  │
│  │      • ProductUpdated                                   │  │
│  │      • ProductStockChanged                              │  │
│  └─────────────────────────────────────────────────────────┘  │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │  Money (Value Object)                                   │  │
│  │  • Amount + Currency                                     │  │
│  │  • Immutable                                            │  │
│  │  • Equality by value                                    │  │
│  └─────────────────────────────────────────────────────────┘  │
│                                                               │
├───────────────────────────────────────────────────────────────┤
│                   Infrastructure Layer                        │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │  ProductRepository (implements IProductRepository)      │  │
│  │  • GetByIdAsync()                                       │  │
│  │  • GetAllAsync()                                        │  │
│  │  • AddAsync()                                           │  │
│  │  • UpdateAsync()                                        │  │
│  │  • DeleteAsync()                                        │  │
│  └─────────────────────────────────────────────────────────┘  │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │  ApplicationDbContext (EF Core)                         │  │
│  │  • DbSet<Product>                                       │  │
│  │  • Entity Configurations                                │  │
│  └─────────────────────────────────────────────────────────┘  │
│                          │                                     │
│                          ▼                                     │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │               Database (SQL Server / InMemory)          │  │
│  └─────────────────────────────────────────────────────────┘  │
└───────────────────────────────────────────────────────────────┘

Code Walkthrough

1. 🎯 Domain Layer: The Heart of the Application

Product Entity (Aggregate Root)

The Product entity encapsulates all business logic and rules:

// src/DotNetCleanArchitecture.Domain/Entities/Product.cs

public sealed class Product : BaseEntity
{
    // Properties with private setters (Encapsulation)
    public string Name { get; private set; }
    public string Sku { get; private set; }
    public Money Price { get; private set; }        // Value Object
    public int StockQuantity { get; private set; }
    public bool IsActive { get; private set; }

    // Private constructor for EF Core
    private Product() { }

    // Factory Method - Only way to create a Product
    public static Product Create(
        string name, 
        string sku, 
        Money price, 
        int stockQuantity)
    {
        // ✅ Business Rules Enforced Here
        if (string.IsNullOrWhiteSpace(name))
            throw new ArgumentException("Product name cannot be empty");

        if (name.Length > 200)
            throw new ArgumentException("Name cannot exceed 200 characters");

        if (string.IsNullOrWhiteSpace(sku))
            throw new ArgumentException("SKU cannot be empty");

        var product = new Product
        {
            Name = name,
            Sku = sku,
            Price = price,
            StockQuantity = stockQuantity,
            IsActive = true
        };

        // ✅ Domain Event Published
        product.AddDomainEvent(
            new ProductCreatedDomainEvent(product.Id, product.Name, product.Sku)
        );

        return product;
    }

    // Business Operations
    public void AddStock(int quantity)
    {
        if (quantity <= 0)
            throw new ArgumentException("Quantity must be positive");

        StockQuantity += quantity;
        SetUpdatedAt();

        // Publish domain event
        AddDomainEvent(new ProductStockChangedDomainEvent(Id, StockQuantity));
    }

    public void RemoveStock(int quantity)
    {
        if (quantity <= 0)
            throw new ArgumentException("Quantity must be positive");

        if (StockQuantity < quantity)
            throw new InvalidOperationException("Insufficient stock");

        StockQuantity -= quantity;
        SetUpdatedAt();

        AddDomainEvent(new ProductStockChangedDomainEvent(Id, StockQuantity));
    }

    public void Activate() => IsActive = true;
    public void Deactivate() => IsActive = false;
    public bool IsInStock() => StockQuantity > 0;
    public bool IsAvailable() => IsActive && IsInStock();
}

Key Points:

✅ Encapsulation: Private setters prevent invalid state
✅ Factory Method: Create() ensures valid object creation
✅ Business Rules: Validation inside the entity
✅ Domain Events: Track important business events
✅ Rich Behavior: Methods that make sense in business context

Money Value Object

Value objects represent concepts that are defined by their attributes:

// src/DotNetCleanArchitecture.Domain/ValueObjects/Money.cs

public sealed class Money : ValueObject
{
    public decimal Amount { get; private set; }
    public string Currency { get; private set; }

    private Money(decimal amount, string currency)
    {
        Amount = amount;
        Currency = currency;
    }

    // Factory method with validation
    public static Money Create(decimal amount, string currency = "USD")
    {
        if (amount < 0)
            throw new ArgumentException("Amount cannot be negative");

        if (string.IsNullOrWhiteSpace(currency))
            throw new ArgumentException("Currency cannot be empty");

        return new Money(amount, currency.ToUpperInvariant());
    }

    // Business operations
    public Money Add(Money other)
    {
        if (Currency != other.Currency)
            throw new InvalidOperationException(
                "Cannot add money with different currencies"
            );

        return new Money(Amount + other.Amount, Currency);
    }

    // Value objects are compared by value, not reference
    protected override IEnumerable<object?> GetEqualityComponents()
    {
        yield return Amount;
        yield return Currency;
    }

    public override string ToString() => $"{Amount:N2} {Currency}";
}

Why Value Objects?

✅ Immutability: Cannot be changed after creation
✅ Self-Validation: Business rules enforced
✅ Equality by Value: Two Money objects with same amount/currency are equal
✅ Type Safety: Can’t accidentally mix up price with quantity

2. Application Layer: Use Cases (CQRS)

Create Product Command

Commands handle write operations:

// src/DotNetCleanArchitecture.Application/UseCases/Products/Commands/CreateProductCommand.cs

public sealed class CreateProductCommand
{
    private readonly IProductRepository _productRepository;
    private readonly IUnitOfWork _unitOfWork;

    public CreateProductCommand(
        IProductRepository productRepository,
        IUnitOfWork unitOfWork)
    {
        _productRepository = productRepository;
        _unitOfWork = unitOfWork;
    }

    public async Task<ProductDto> ExecuteAsync(
        CreateProductDto dto, 
        CancellationToken cancellationToken = default)
    {
        // ✅ Business validation
        if (await _productRepository.SkuExistsAsync(dto.Sku, cancellationToken))
        {
            throw new InvalidOperationException(
                $"Product with SKU '{dto.Sku}' already exists"
            );
        }

        // ✅ Use domain factory method
        var price = Money.Create(dto.Price, dto.Currency);
        var product = Product.Create(
            dto.Name,
            dto.Sku,
            price,
            dto.StockQuantity
        );

        // ✅ Persist through repository
        await _productRepository.AddAsync(product, cancellationToken);
        await _unitOfWork.SaveChangesAsync(cancellationToken);

        // ✅ Return DTO (not domain entity)
        return MapToDto(product);
    }

    private static ProductDto MapToDto(Product product)
    {
        return new ProductDto
        {
            Id = product.Id,
            Name = product.Name,
            Sku = product.Sku,
            Price = product.Price.Amount,
            Currency = product.Price.Currency,
            StockQuantity = product.StockQuantity,
            IsActive = product.IsActive,
            CreatedAt = product.CreatedAt
        };
    }
}

Key Points:

✅ Single Responsibility: Only creates products
✅ Uses Domain Logic: Calls Product.Create()
✅ Repository Pattern: Abstracts data access
✅ Unit of Work: Manages transactions
✅ DTOs: External representation separate from domain

Get Products Query

Queries handle read operations:

// src/DotNetCleanArchitecture.Application/UseCases/Products/Queries/GetAllProductsQuery.cs

public sealed class GetAllProductsQuery
{
    private readonly IProductRepository _productRepository;

    public GetAllProductsQuery(IProductRepository productRepository)
    {
        _productRepository = productRepository;
    }

    public async Task<IReadOnlyList<ProductDto>> ExecuteAsync(
        CancellationToken cancellationToken = default)
    {
        var products = await _productRepository.GetAllAsync(cancellationToken);
        return products.Select(MapToDto).ToList();
    }

    private static ProductDto MapToDto(Product product)
    {
        return new ProductDto
        {
            Id = product.Id,
            Name = product.Name,
            Sku = product.Sku,
            Price = product.Price.Amount,
            Currency = product.Price.Currency,
            StockQuantity = product.StockQuantity,
            IsActive = product.IsActive,
            CreatedAt = product.CreatedAt,
            UpdatedAt = product.UpdatedAt
        };
    }
}

CQRS Benefits:

✅ Separation: Read and write models are separate
✅ Optimization: Can optimize queries differently than commands
✅ Scalability: Can scale reads and writes independently
✅ Clarity: Clear intent (command vs query)

3. Infrastructure Layer: Implementation Details

Repository Implementation

// src/DotNetCleanArchitecture.Infrastructure/Persistence/Repositories/ProductRepository.cs

public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _context;

    public ProductRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<Product?> GetByIdAsync(
        Guid id, 
        CancellationToken cancellationToken = default)
    {
        return await _context.Products
            .FirstOrDefaultAsync(p => p.Id == id, cancellationToken);
    }

    public async Task<IReadOnlyList<Product>> GetAllAsync(
        CancellationToken cancellationToken = default)
    {
        return await _context.Products
            .OrderBy(p => p.Name)
            .ToListAsync(cancellationToken);
    }

    public async Task<Product> AddAsync(
        Product product, 
        CancellationToken cancellationToken = default)
    {
        await _context.Products.AddAsync(product, cancellationToken);
        return product;
    }

    public async Task<bool> SkuExistsAsync(
        string sku, 
        CancellationToken cancellationToken = default)
    {
        return await _context.Products
            .AnyAsync(p => p.Sku == sku, cancellationToken);
    }

    // ... other methods
}

Entity Framework Configuration

// src/DotNetCleanArchitecture.Infrastructure/Persistence/Configurations/ProductConfiguration.cs

public class ProductConfiguration : IEntityTypeConfiguration<Product>
{
    public void Configure(EntityTypeBuilder<Product> builder)
    {
        builder.ToTable("Products");
        builder.HasKey(p => p.Id);

        builder.Property(p => p.Name)
            .IsRequired()
            .HasMaxLength(200);

        builder.Property(p => p.Sku)
            .IsRequired()
            .HasMaxLength(50);

        builder.HasIndex(p => p.Sku)
            .IsUnique();

        // ✅ Value Object as Owned Entity
        builder.OwnsOne(p => p.Price, priceBuilder =>
        {
            priceBuilder.Property(m => m.Amount)
                .HasColumnName("Price")
                .HasPrecision(18, 2)
                .IsRequired();

            priceBuilder.Property(m => m.Currency)
                .HasColumnName("Currency")
                .HasMaxLength(3)
                .IsRequired();
        });

        // ✅ Ignore domain events (not persisted)
        builder.Ignore(p => p.DomainEvents);
    }
}

Key Points:

✅ Fluent API: Configuration separate from domain
✅ Owned Entities: Value objects mapped correctly
✅ Constraints: Database constraints mirror business rules

4. Presentation Layer: REST API

Products Controller

// src/DotNetCleanArchitecture.WebAPI/Controllers/ProductsController.cs

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly CreateProductCommand _createProductCommand;
    private readonly GetAllProductsQuery _getAllProductsQuery;
    private readonly GetProductByIdQuery _getProductByIdQuery;
    private readonly ILogger<ProductsController> _logger;

    public ProductsController(
        CreateProductCommand createProductCommand,
        GetAllProductsQuery getAllProductsQuery,
        GetProductByIdQuery getProductByIdQuery,
        ILogger<ProductsController> logger)
    {
        _createProductCommand = createProductCommand;
        _getAllProductsQuery = getAllProductsQuery;
        _getProductByIdQuery = getProductByIdQuery;
        _logger = logger;
    }

    /// <summary>
    /// Get all products
    /// </summary>
    [HttpGet]
    [ProducesResponseType(typeof(IReadOnlyList<ProductDto>), 200)]
    public async Task<ActionResult<IReadOnlyList<ProductDto>>> GetAll(
        CancellationToken cancellationToken)
    {
        try
        {
            var products = await _getAllProductsQuery.ExecuteAsync(cancellationToken);
            return Ok(products);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting all products");
            return StatusCode(500, "An error occurred");
        }
    }

    /// <summary>
    /// Create a new product
    /// </summary>
    [HttpPost]
    [ProducesResponseType(typeof(ProductDto), 201)]
    [ProducesResponseType(400)]
    public async Task<ActionResult<ProductDto>> Create(
        [FromBody] CreateProductDto dto,
        CancellationToken cancellationToken)
    {
        try
        {
            var product = await _createProductCommand.ExecuteAsync(
                dto, 
                cancellationToken
            );
            
            return CreatedAtAction(
                nameof(GetById), 
                new { id = product.Id }, 
                product
            );
        }
        catch (ArgumentException ex)
        {
            _logger.LogWarning(ex, "Validation error");
            return BadRequest(ex.Message);
        }
        catch (InvalidOperationException ex)
        {
            _logger.LogWarning(ex, "Business rule violation");
            return BadRequest(ex.Message);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating product");
            return StatusCode(500, "An error occurred");
        }
    }

    // ... other endpoints
}

Controller Responsibilities:

✅ HTTP Concerns: Handle requests/responses
✅ Validation: Input validation (can add FluentValidation)
✅ Orchestration: Call appropriate use cases
✅ Error Handling: Convert exceptions to HTTP status codes
✅ Logging: Log important events

Dependency Injection Setup

// src/DotNetCleanArchitecture.WebAPI/Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddOpenApi();

// ✅ Register Application Layer
builder.Services.AddApplication();

// ✅ Register Infrastructure Layer
builder.Services.AddInfrastructure(builder.Configuration);

var app = builder.Build();

// Configure middleware
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
}

app.UseHttpsRedirection();
app.MapControllers();

app.Run();

🔄 Request Flow Example

Let’s trace a complete request through all layers:

Creating a Product: Step-by-Step

1️⃣  HTTP Request
    │
    │  POST /api/products
    │  {
    │    "name": "Wireless Mouse",
    │    "sku": "MOUSE-001",
    │    "price": 29.99,
    │    "currency": "USD",
    │    "stockQuantity": 50
    │  }
    │
    ▼

2️⃣  ProductsController (WebAPI Layer)
    │  • Receives HTTP request
    │  • Validates input
    │  • Calls CreateProductCommand
    │
    ▼

3️⃣  CreateProductCommand (Application Layer)
    │  • Checks if SKU already exists (business rule)
    │  • Creates Money value object
    │  • Calls Product.Create() factory method
    │
    ▼

4️⃣  Product.Create() (Domain Layer)
    │  • Validates business rules
    │  • Creates Product entity
    │  • Publishes ProductCreatedDomainEvent
    │  • Returns valid Product
    │
    ▼

5️⃣  ProductRepository.AddAsync() (Infrastructure Layer)
    │  • Adds product to DbContext
    │
    ▼

6️⃣  UnitOfWork.SaveChangesAsync() (Infrastructure Layer)
    │  • Commits transaction to database
    │  • Dispatches domain events
    │
    ▼

7️⃣  Response Back to Client
    │  • Maps Product to ProductDto
    │  • Returns 201 Created with product data
    │
    └──► HTTP Response
         {
           "id": "123e4567-e89b-12d3-a456-426614174000",
           "name": "Wireless Mouse",
           "sku": "MOUSE-001",
           "price": 29.99,
           "currency": "USD",
           "stockQuantity": 50,
           "isActive": true,
           "createdAt": "2025-12-21T10:30:00Z"
         }

✨ Best Practices

✅ DO

Keep Domain Pure

// ✅ Good: Pure domain logic
public void AddStock(int quantity)
{
    if (quantity <= 0)
        throw new ArgumentException("Quantity must be positive");

    StockQuantity += quantity;
}

Use Factory Methods

// ✅ Good: Factory method enforces rules
public static Product Create(string name, string sku, Money price)
{
    if (string.IsNullOrWhiteSpace(name))
        throw new ArgumentException("Name required");

    return new Product { Name = name, Sku = sku, Price = price };
}

Encapsulate with Private Setters

// ✅ Good: Cannot be modified from outside
public string Name { get; private set; }

Use Value Objects

// ✅ Good: Money is a value object
public Money Price { get; private set; }

// ❌ Bad: Primitives can be mixed up
public decimal Price { get; set; }
public string Currency { get; set; }

Define Interfaces in Application Layer

// Application/Interfaces/IProductRepository.cs
public interface IProductRepository
{
    Task<Product?> GetByIdAsync(Guid id);
}

❌ DON’T

Don’t Reference Outer Layers from Inner Layers

// ❌ BAD: Domain referencing Infrastructure
public class Product
{
    private readonly IProductRepository _repository; // WRONG!
}

Don’t Put Business Logic in Controllers

// ❌ BAD: Business logic in controller
[HttpPost]
public async Task<IActionResult> Create(CreateProductDto dto)
{
    if (string.IsNullOrEmpty(dto.Name)) // Business rule in wrong place
        return BadRequest();

    var product = new Product { Name = dto.Name }; // Direct instantiation
    await _context.Products.AddAsync(product); // Direct DB access
    await _context.SaveChangesAsync();
    return Ok();
}

Don’t Expose Domain Entities Directly

// ❌ BAD: Returning domain entity
[HttpGet]
public async Task<Product> Get(Guid id)
{
    return await _repository.GetByIdAsync(id);
}

// ✅ GOOD: Return DTO
[HttpGet]
public async Task<ProductDto> Get(Guid id)
{
    var product = await _repository.GetByIdAsync(id);
    return MapToDto(product);
}

🤔 When to Use Clean Architecture

✅ Use Clean Architecture When:

✅ Building complex business applications with lots of business rules
✅ Project has a long lifespan (5+ years)
✅ Multiple teams working on different parts
✅ Requirements are likely to change frequently
✅ Need to support multiple platforms (Web, Mobile, Desktop)
✅ Testability is critical
✅ Technology stack might change (database, framework, etc.)

⚠️ Consider Alternatives When:

⚠️ Building a simple CRUD application with minimal business logic
⚠️ Rapid prototyping or MVP development
⚠️ Very small team (1-2 developers)
⚠️ Short-lived project (< 6 months)
⚠️ Team is unfamiliar with design patterns and DDD
⚠️ Time to market is more important than architecture

📊 Summary of Our Implementation

🏢 What We Built

A Product Management System demonstrating:

Layer	What We Created	Purpose
Domain	Product entity, Money value object, Domain events	Pure business logic
Application	Create/Update/Delete commands, Get queries, DTOs	Use cases and orchestration
Infrastructure	EF Core repository, DbContext, configurations	Data access implementation
WebAPI	REST API controller, 5 endpoints	HTTP interface

🔑 Key Patterns Used

✅ Clean Architecture        → Layered structure with dependency rule
✅ Domain-Driven Design       → Entities, Value Objects, Events
✅ CQRS                       → Commands and Queries separated
✅ Repository Pattern         → Abstract data access
✅ Unit of Work Pattern       → Transaction management
✅ Factory Pattern            → Product.Create() method
✅ Dependency Injection       → Loose coupling throughout
✅ SOLID Principles           → All five principles applied

📈 Project Statistics

26 C# Files across 4 layers
1 Aggregate Root (Product)
1 Value Object (Money)
3 Domain Events
3 Commands (Write operations)
2 Queries (Read operations)
5 REST Endpoints
0 Framework Dependencies in Domain layer

⚖️ Business Rules Enforced

✅ Product name is required and max 200 characters
✅ SKU must be unique
✅ Price cannot be negative
✅ Stock quantity cannot be negative
✅ Cannot remove more stock than available
✅ Currency must be valid (3-letter code)
✅ Domain events published for important actions

🎯 Conclusion

Clean Architecture provides a robust foundation for building maintainable, testable, and scalable applications. While it requires more upfront investment, the long-term benefits are substantial:

💡 Key Takeaways

Independence is Key: Business logic should be independent of frameworks, UI, and databases
The Dependency Rule: Dependencies always point inward—inner layers know nothing about outer layers
Testability: With proper separation, you can test business logic without any infrastructure
Flexibility: Swap out databases, frameworks, or UI without touching core business logic
Maintainability: Clear boundaries make code easier to understand and modify
Team Collaboration: Different teams can work on different layers independently

💰 Is It Worth It?

For complex business applications with long lifespans: Absolutely YES ✅
For simple CRUD apps or rapid prototypes: Probably NOT ❌

� Final Thoughts

Clean Architecture is not a silver bullet, but when applied appropriately, it creates systems that are:

Easy to test
Easy to understand
Easy to maintain
Easy to extend
Hard to break

The key is knowing when to use it and how much complexity to introduce based on your project’s needs.

📚 Resources

📖 Official Documentation

Clean Architecture by Robert C. Martin (Uncle Bob)
Domain-Driven Design by Eric Evans
Microsoft’s eShopOnContainers (reference implementation)

💾 Implementation Repository

GitHub Repository: DotNetCleanArchitecture

Project structure:

Domain: src/DotNetCleanArchitecture.Domain/
Application: src/DotNetCleanArchitecture.Application/
Infrastructure: src/DotNetCleanArchitecture.Infrastructure/
WebAPI: src/DotNetCleanArchitecture.WebAPI/

Clone and run:

git clone https://github.com/yourusername/DotNetCleanArchitecture.git
cd DotNetCleanArchitecture
dotnet restore
dotnet run --project src/DotNetCleanArchitecture.WebAPI

📖 Further Reading

Related Articles:

Clean Architecture in .NET Overall - Fundamentals and principles
Common Clean Architecture Mistakes in .NET - Avoid these antipatterns!

Patterns & Principles:

SOLID Principles
CQRS Pattern
Event Sourcing
Repository Pattern
Unit of Work Pattern
Dependency Injection

Questions? Leave a comment below. Happy coding!!!

Clean Architecture in .NET Realworld Example

💻 GitHub Repository

📦 What’s Included:

🏗️ Real-World Implementation: Product Management System

📊 System Overview

🎨 Architecture Diagram

Code Walkthrough

1. 🎯 Domain Layer: The Heart of the Application

Product Entity (Aggregate Root)

Money Value Object

2. Application Layer: Use Cases (CQRS)

Create Product Command

Get Products Query

3. Infrastructure Layer: Implementation Details

Repository Implementation

Entity Framework Configuration

4. Presentation Layer: REST API

Products Controller

Dependency Injection Setup

🔄 Request Flow Example

Creating a Product: Step-by-Step

✨ Best Practices

✅ DO

❌ DON’T

🤔 When to Use Clean Architecture

✅ Use Clean Architecture When:

⚠️ Consider Alternatives When:

📊 Summary of Our Implementation

🏢 What We Built

🔑 Key Patterns Used

📈 Project Statistics

⚖️ Business Rules Enforced

🎯 Conclusion

💡 Key Takeaways

💰 Is It Worth It?

� Final Thoughts

📚 Resources

📖 Official Documentation

💾 Implementation Repository

📖 Further Reading

Related Content