Implementing Clean Architecture in .NET

Overview

Clean architecture slowly seems to be gaining lots and lots of traction these days. After all, the approach is highly considered for designing and developing software applications which are easy to maintain, test and separate. The following post, as the title suggests, emphasises on what clean architecture is, how it is beneficial, and how to implement it in a .NET Core project, overall, why it is believed to offer a solid foundation for future development.

What exactly is clean architecture?

Often known as Hexagonal or Onion Architecture, clean architecture as a technology was introduced by Robert C Martin with an objective to develop software-based applications which ensure long-term success and maintenance. Technically speaking, the following concept was mainly to develop a successful decoupled as well as modular architecture enabling developers to successfully to build, test, as well maintain their apps independently of external dependencies featuring databases, user interfaces, as well as external services.

So this technology is a software design pattern which focuses highly on the separation of concerns as well as the use of abstractions for seamless promotion of a highly flexible, easy to maintain and scalable codebase. Still confused, well, here the elements of design are separated among different ring levels. In fact, do you know what is the most unusual yet amazing aspect of clean architecture is? It successfully encapsulates the business logic but keeps it separate from the delivery mechanism.

What is the main rule here? Code dependencies shouldn’t be able to move from inner to outer levels, since inner layers aren’t supposed to have knowledge of the functions available in the outer layers. This architecture is the core reason why developers are able to develop robust, scalable and highly flexible types of applications.

• Easy to understand and modify, so the chances of risk are minimised automatically.
• Designed in such a manner that testing is no longer twisted, and mostly automation tests are conducted.
• Possible for frameworks to be replaced with minimal impact
• Possible to make changes without affecting the underlying logic as well as the business rules
• Data storage and retrieval mechanisms can change
• Highly independent of any kind of external agencies.

Above all, clean architecture can assist in keeping the code under the control and keeping it tidy as well as clean. The tech was introduced with the thought process of writing down the code without any kind of dependency, which isn’t more likely to change any time soon. Be it if you happen to change the framework version, database or UI-related code, the core is no longer entitled to changes.

Top Principles of Clean Architecture

• Separation of concerns – As the name itself suggests, the app is divided into multiple range of layers, each responsible for different kinds of work and aspects. So this means you are bound to experience a highly modular design as well as get rid of issues leading to tight coupling.
• Dependency inversion principle – High-level modules shouldn’t depend on the low-level ones. On the contrary, they need to depend heavily on abstractions which be replaced seamlessly and expand when required.
• Testability – Designing the app in a decoupled manner, so it is easy to write different types of unit and integration tests, ensuring the app stays easy to maintain and bug-free.
• Agile development – Clean architecture highly promotes agile development methodology, focusing on iterative and incremental improvements.

Created by Robert Martin, clean architecture highly focuses on cost-effective methodology, which ensures the development of high code quality featuring fewer dependencies.

*Entities *– One of the most crucial aspects to the development of any business application. However, it may be quite surprising for you to know that this layer has no idea regarding other layers, which means they aren’t dependent on anything else. Even if there is no app, they can exist. This can be considered as the core layer featuring application-independent business logic.

• From Aggregates to entities, value objects, custom domain exceptions, and interfaces are clearly defined here.
• Commands and Queries models and handlers
• Interfaces for domain-driven design concepts
• Authorization operations, requirements, and handlers implementations
• Base implementations of aggregate root and domain events.
• Mapping profiles between domain entities and CQRS models.

Interface layers – The next one is the interface layer, which ensures the entire system is automated. In contrast to entities, this layer mainly comprises of specific business rules, and even so, this layer has no idea about other layers apart from entities. This layer features interfaces as well as abstract classes, which can be used by further available layers.

• ASP.NET Core MVC web application using Razor Components

• A shared class library containing common Razor Components, such as toast notifications, modal components, Blazor Select2, DataTablesJS integration, and CRUD buttons.

• Adapter layers – This one works as an adapter between the domain and the infrastructure. In addition to all this, you will certainly find a generic result wrapper, CLR type extensions, notification models, custom attributes and converters and more.

• Infrastructure layer – One of the most social layers, which is more likely to change, especially from other stable domain layers. This definitely prevents coupling as well as effectively stabilises the domain layers. Here you will mainly find:

• Generic and specific repository implementations

• EF DbContexts, data models, and migrations

• Event sourcing, persistence, and service implementations

• Implementations for cross-cutting concerns (i.e., application configuration service, localisation service, etc.)

• Data entity auditing implementation

The ultimate objective is to divide the app into different levels featuring their very own modules, classes and share similar kinds of responsibilities. Now we will focus on how is this clean architecture is beneficial in the long run.

Benefits of considering clean architecture

Easy to maintain

One of the obvious advantages to consider here is that clean architecture is pretty much easy when it comes to maintenance. In fact, at the same time, it highly promotes modularity since the tech involves quick separation among distinct layers. So codebase becomes more maintainable and enables quick updates as well as changes, especially to a few components which does need to change, and this has nothing to do with the impact on the entire app.

Test

The next one to take into account is the test. Yes, another amazing advantage to take into account is testability. Since the separation of concerns is done, it is easy to conduct unit testing. As mentioned, the business logic is in the core layer, so it is possible to conduct tests separately, which certainly leads to robust and reliable tests.

Ease of collaboration

As you can see for yourself, here everything is well organised. In other words, it is easy to rope in more than one developer at the same time to work on the same codebase concurrently.

High flexibility

It is possible to achieve high flexibility and robustness, especially for different layers, since here you are free to choose the technology and switch between web frameworks, databases or UI frameworks without major changes to the core business logic. Also, this goes without saying that clean architecture offers higher scalability as well.

Independence of Frameworks

In addition to flexibility, since the core isn’t tightly coupled with all frameworks and libraries, it is easy to switch or upgrade frameworks without even having a significant effect on the core functionality.

Are there any disadvantages?

• Complexity – There are times when clean architecture can introduce additional complexities, especially in the early stages of development. The separation of concerns can work adversely, especially for smaller projects.
• Learning curve – Clean architecture can be a bit tricky to deal with, especially if you are new. The learning curve is a bit difficult, and getting started with such projects might take some time.
• Performance overhead – The additional layers and abstractions can result in unwanted performance overhead. As a solution, you need to be thorough with consideration and optimisation, especially if you are developing performance-critical applications.

Setting Up a .NET Core Project

By now, I am sure you must have a basic understanding of what clean architecture is and how it is beneficial in the long run. Time to implement what we have learned, time to implement clean architecture in .NET.

However, many of you might find this a bit daunting at first, but make sure to choose the right tools and dependencies, and you will be sorted.

Step 1 – Installing Required Tools and Dependencies

.NET Core SDK – Download and install the latest versions from the official website, so you are bound to have instant access to all required tools and libraries.

IDE or Integrated Development Environment – Make sure to use popular IDEs such as Visual Studio or Visual Studio Code so that you won’t be bothered much when conducting development, as well as debugging. Also, here managing the codebase becomes more easier.

Git – Lastly, it is very important to have a version control system so that the project’s history can be taken care of even if the teammates change or the new ones are roped in.

Step 2 – Creating a New .NET Core Solution

First, open your preferred IDE and create a new solution (try using the .NET Core template here)

Try naming the solution according to pre-defined project requirements and choose an appropriate location, and save. So that it can be way easier to keep tabs on all project files.

Add Domain, Application, Infrastructure, and Presentation projects, so it is possible to code in reference to clean architecture, which means developing and scaling, and maintenance automatically becomes easier.
Save and now begin with organising the project structure, which involves creating folders and files, and do not forget to define dependencies among them clearly.

Domain layer – It must comprise of pure business logic and data structures. It defines entities, value objects, and domain services.
Application layer – Conducting seamless coordination among the Domain layer and the Infrastructure layer is what needs to be done here. It defines high-level behaviour of the system.

Infrastructure layer – It comprises of code which interacts with external dependencies such as databases, file systems, and external APIs. This layer is easily replaceable.

Presentation layer – It is present for handling the user interface and user input, which means it handles HTTP requests, renders HTML templates, interacts with JavaScript on the client side and more.

Final Words

Clean architecture is slowly and steadily gaining an immense range of recognition, and since it offers such a significant range of advantages, you shouldn’t be neglecting it as well. Though this doesn’t mean it is a one-size-fits-all topic, before you make a choice, make sure you are thorough with your needs and requirements. Also, try looking around for a reputable and reliable .NET development company, which is not just knowledgeable but well-experienced in dealing with such trade-offs. I hope you did find the following post worth reading. In case if you have any kind of doubts or queries, feel free to mention them in the comment section below. Keep watching the space to know more about the same.