Clean Architecture: How to Organize a Project in Layers

The Clean Architecture is a way to separate business rules, use cases, and infrastructure by making dependencies point toward the core of the application.

When you start a small project, putting everything in a controller or in Program.cs is tempting. It’s quick, it’s easy, and it works. As the project grows, that “ease” can end up with business logic mixed with SQL, duplicated validations, and hard-to-write tests.

One way to avoid this is to use a layered architecture. Clean Architecture, popularized by Robert C. Martin (Uncle Bob), is one of the most well-known proposals.

Let’s see how to divide the solution into four projects (.csproj) to achieve more decoupled and easily testable code.

Folder Structure in Visual Studio

Your solution explorer should look like this:

Dependencies

Before looking at the layers, you need to understand the rule that governs everything: The Dependency Rule.

Source code dependencies can only point inward.

Inner layers (the core) must not know anything about outer layers.

• Your Database (Outer) depends on your Domain (Inner), not the other way around.
• Your Domain doesn’t know if you are using SQL Server, Mongo, or an Excel file.
• Your Domain doesn’t know if you are in a Web API, a Console App, or an Azure Function.

The Four Layers of a .NET Solution

In a standard Visual Studio solution, we will create 4 separate projects (Class Libraries):

// Project: MyApp.Domain
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }

    // Pure Logic: A product cannot have a negative price
    public void UpdatePrice(decimal newPrice)
    {
        if (newPrice < 0) throw new DomainException("Invalid price");
        Price = newPrice;
    }
}

// Project: MyApp.Application
public interface IProductRepository
{
    void Add(Product product); // Uses the Domain entity
}

public class CreateProductUseCase
{
    private readonly IProductRepository _repo; // Depends on the abstraction
    // ...
}

// Project: MyApp.Infrastructure
public class SqlProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _db;

    public void Add(Product product)
    {
        _db.Products.Add(product); // Actual implementation with EF Core
    }
}

How does it all connect?

Let’s see the journey of a request to “Create User”: