Clean Architecture

What is Clean Architecture?

Clean Architecture is a design pattern that separates an application into different layers based on their responsibility.  It’s a way of organizing your code into independent, testable, and reusable components. 

It isolates the business logic of the application from external details such as user interfaces, databases, and frameworks.

The primary objective of Clean Architecture is to create a structure that makes it easy to manage and maintain an application as it grows and changes over time. It also makes it easy to add new features, fix bugs, and make changes to existing functionality without affecting the rest of the application.

Implementing Clean Architecture in ASP .NET Core Web API

To apply Clean Architecture, we can divide the application into four primary layers:

Domain Layer – The domain layer represents the application’s core business rules and entities. This is the innermost layer and should not have any external dependencies. It contains domain entities, value objects, and domain services.

Application Layer – The application layer sits just outside the domain layer and acts as an intermediary between the domain layer and other layers. In other words, it contains the use cases of the application and we expose the core business rules of the domain layer through the application layer. This layer depends just on the domain layer.

Infrastructure Layer – We implement all the external services like databases, file storage, emails, etc. in the infrastructure layer. It contains the implementations of the interfaces defined in the domain layer.

Presentation Layer – The presentation layer handles the user interactions and fetches data to the user interface. It contains the user interface components (e.g., MVC, API Controllers, Blazor components).

With Clean Architecture, the Domain and Application layers are at the center of the design. This is known as the Core of the system.

The Domain layer contains enterprise logic and types and the Application layer contains business logic and types. The difference is that enterprise logic could be shared across many systems, whereas the business logic will typically only be used within this system.

Implementing the Project Structure:

Creating the Core Layer:

1. Define Entities and Use Cases.
2. Create a folder named “Core.”
3. Within this folder, classes for Entities such as “User.cs” or “Product.cs” are created.
4. Create interfaces or abstract classes for Use Cases like “IUserService.cs”.

Creating the Application Layer:

1. Implement Use Cases.
2. Create a folder named “Application.”
3. Implement Use Cases as classes that inherit from the interfaces defined in the Core layer.
4. For example: “UserService.cs”.

Creating the Infrastructure Layer:

1. Implement Interface Adapters.
2. Create a folder named “Infrastructure.”
3. Implement concrete classes for the interfaces defined in the Core layer.
4. For example: “UserRepository.cs” for “IUserRepository”.

Project Structure

Benefits of Clean Architecture:

Maintainability: Easier to modify and extend the system.

Flexibility: Adapts to changing requirements with minimal impact on other components.

Scalability: Better suited for large, complex systems.

Reference: 

https://code-maze.com/ , 

https://positiwise.com/, 

https://www.macrix.eu/ ,

https://medium.com/,