avatarSasha Marfut

Summary

This context provides a guide on structuring a .NET project using Clean Architecture principles.

Abstract

Clean Architecture is a popular approach to building software applications, dividing the solution into four main layers: Domain, Application, Infrastructure, and Presentation. Each layer has specific responsibilities and dependencies, with inner circles not knowing anything about the outer circles. The implementation of Clean Architecture in a .NET project involves creating separate projects for each layer, ensuring proper references and file organization. The context also discusses the composition root, where dependency injection is configured.

Opinions

  • Clean Architecture improves maintainability by defining clear boundaries between application layers.
  • The business logic in Clean Architecture remains independent of any specific external frameworks or libraries.
  • The domain layer contains domain logic, entities, value objects, and repository interfaces, and does not depend on any other layer.
  • The application layer contains application use cases and infrastructure abstractions, only having a reference to the domain layer.
  • The infrastructure layer implements abstractions defined in the application and domain layers, containing repositories, database migrations, and other service implementations.
  • The presentation layer serves as the entry point to the application, containing a public API and other elements needed to serve incoming requests.
  • The composition root in the presentation layer configures dependency injection via a series of extension method calls in the Program class.

How to Structure .NET Project with Clean Architecture?

Clean Architecture in Practice.

Photo by Oliver Hale on Unsplash

Clean Architecture is a popular approach to building software applications.

A Clean Architecture defines clear boundaries between different application layers, resulting in improved maintainability.

In addition, Clean Architecture approach aims to keep the business logic independent of any specific external frameworks or libraries, making it easier to migrate to new technologies.

In this article, we will look at how to structure a .NET project using Clean Architecture principles.

The Clean Architecture approach divides the solution into four main layers:

  • Domain (core logic)
  • Application (application use cases)
  • Infrastructure (data access, caching…)
  • Presentation (public API)

How do these layers depend on each other?

An important rule about dependencies between layers is that any inner circle must not know anything about the outer circles.

Therefore, dependencies between layers can only be directed inward.

Implementation of Clean Architecture

How to implement a clean architecture in a .NET project?

The easiest way is to create a separate project for each of the four layers shown in the diagram.

However, a little later in the article, we will adjust this approach a bit.

Now let’s talk about each layer individually.

Domain Layer

The domain layer is where the domain logic of the application is defined.

This layer contains things like entities, value objects, domain services, domain exceptions, domain events, repository interfaces, and so on.

Important thing is that the domain layer does not depend on any other layer. It depends only on .NET primitive types (int, string, etc).

When it comes to grouping files into folders within a domain project, there are two common ways to do this.

The first option would be to group files by their type:

All entities are placed in the Entities folder, all exceptions are placed in the Exception folder, and so on.

Another approach is to use entity folders.

For example, if the application contains domain logic related to users and orders, the file structure might look like this:

For a large domain layer, grouping by functionality by type (the first approach) may work better, because there will be no problem selecting a folder to put the file in. However, the second approach may have such difficulties, for example, when the same value object belongs to several different entities.

Application Layer

The application layer contains application’s use cases, which can be implemented as command and query handlers or simply as application service classes. In addition, the application layer is usually the place to define infrastructure abstractions (for caching, sending emails, etc).

Here’s what the folder structure might look like:

When it comes to references to other projects, the application layer only has a reference to the domain layer.

Infrastructure Layer

The infrastructure layer implements abstractions defined in application and domain layers.

The infrastructure layer can contain:

  • Repositories and database migrations
  • Implementation of caching services
  • Implementation of identity providers
  • Implementation of email providers

If the infrastructure layer is implemented as a single project, it may become too bloated over time.

To avoid this problem, we can implement the infrastructure layer as a folder with individual projects in it:

This approach provides a better separation of concerns.

The infrastructure layer must reference the domain and application projects to implement the abstractions defined in them.

Presentation Layer

The presentation layer serves as the entry point to the application.

It contains a public API (for example, RESTful endpoints) that external users or applications can interact with.

In addition to endpoints, the Presentation layer contains other elements needed to serve incoming requests, such as middlewares.

In addition, the presentation project acts as the composition root of the entire solution.

Composition root is where the dependency injection is configured.

Typically it’s done via a series of extension method calls in the Program class:

builder.Services
    .AddDomainServices()
    .AddApplicationServices()
    .AddDataAccessServices()
    .AddEmailNotificationSErvices()
    .AddCachingServices();

The presentation layer must reference the application layer in order to execute application use cases.

We looked at how to structure .NET applications using Clean Architecture principles. We saw how layers of Clean Architecture are mapped to .NET projects, how they should reference each other, and how to organize files within each project.

Thanks for reading. If you liked what you read, check out this story below:

🔔Also, consider supporting me on Buy Me a Coffee.

If you enjoyed this article, consider trying out the AI service I recommend. It provides the same performance and functions to ChatGPT Plus(GPT-4) but more cost-effective, at just $6/month (Special offer for $1/month). Click here to try ZAI.chat.

Programming
Software Development
Csharp
Clean Architecture
Dotnet
Recommended from ReadMedium