Software Architecture The Onion Architecture by Shivendra Odean

This guarantees that the domain layer will always be portable and independent. By establishing distinct boundaries between the layers, the design makes it simpler to maintain the program. The program should continue to function if changes are made to one layer without affecting the others, which makes it simpler to make changes. A curated list of awesome articles, videos, and other resources to learn and practice software architecture, patterns, and principles. Then we saw how the Service layer was created, where we are encapsulating our business logic. We started with the Domain layer, where we saw the definitions for our entities and repository interfaces and exceptions.

This is where our database, message queue, and perhaps a file system lives. This layer is unique, because it provides to the application in a supporting manner. Because the business has no notion of the outside world — for example, it doesn’t know its data is stored in a database — the outside world can never contaminate the domain. This way, you are able to keep the core of the application relatively simple; focused on business-specific operations without having to account for endless “what-if’s”. The Onion Architecture was first introduced by Jeffrey Palermo around 2008.

Part 4 — Accessing Data

The Service layer also could hold business logic for an entity. In this layer, service interfaces are kept separate from its implementation, keeping loose coupling and separation of concerns in mind. The core of the business logic should be free (in theory at least) from any of the technical, and
framework-related problems, allowing for easy testing and rapid development. Database – This is underlying database and will contain the data
2. OData API – This API will interact with database and will perform database related operations only (CRUD). I want this API to be only platform to access and manipulate data.

• One of the primary benefits of onion architecture is its ability to promote maintainability.
• The Infrastructure Layer should not implement any business logic, as well as any use case flow.
• That’s why it was difficult to immediately divide the functionality into the necessary microservices.
• This article will explore Onion Architecture and its key components, benefits, and best practices.
• Onion Architecture is suitable for most types of applications, but it is particularly useful for complex and long-lived applications that require a high level of maintainability and scalability.

We can implement this layer in many ways, for example creating a REST API, gRPC, etc. To learn how to implement the repository pattern with Entity Framework Core you can check out this article ASP.NET Core Web API – Repository Pattern. Let us take a look at what are the advantages of Onion architecture, and why we would want to implement it in our projects. Conceptually, we can consider that the Infrastructure and Presentation layers are on the same level of the hierarchy. No, Onion Architecture is a language- and framework-agnostic pattern that can be implemented using any programming language or framework.

When to Consider Clean Architecture: A Practical Guide

The User Interface layer is responsible for presenting the information to the user and receiving input from the user. It can be a web application, a mobile application, or a desktop application. The User Interface layer depends on the Application layer and interacts with the user using the services and interfaces provided by the Application layer. Let’s look at one of the most popular Architecture in ASP.NET Core Applications.

Because the layers of the Onion Architecture are loosely connected and can be tested separately from one another, writing automated tests for the application is made simpler. The Onion Architecture encourages a distinct division of responsibilities between the application’s many layers. This increases the application’s modularity and makes it simpler to comprehend and maintain. Each layer has a specific responsibility and interacts with the layer adjacent to it. We have now set our expectations for anyone wishing to charge a user for a transaction within our Application Services layer. However, we are not doing anything useful at the moment with the transaction so from this and following the layers of Onion Architecture we need to define our Domain Services layer.

domain-driven-hexagon

React + TypeScript app built using the clean architecture principles in a more functional way. The great thing about this approach is that the migrations will be automatically applied when we create new migrations, further down the road. To learn more about migrations and how to seed data with EF Core in both .NET 5 and .NET 6 check out this article Migrations and Seed Data with Entity Framework Core. However, since the Web application and the database server will be running inside of containers, how are we going to create the actual database for the application to use? We could create an initialization script, connect to the Docker container while it is running the database server, and execute the script. To make it straightforward to download the application code and be able to run the application locally we are using Docker.

Create a new folder named Context and add a new class ApplicationDbContext. With the CRUD logic out of the way, let’s set up EFCore in the Persistence Layer and try to generate a database. Install the following packages to the Persistence Project. I have already written a detailed article on MediatR and CQRS patterns in ASP.NET Core 3.1 WebApi Project. You can follow that article and add the Required Commands and Handlers to the Application Layer. As a result, if done well, the onion architecture significantly reduce the amount of refactoring by separating application and infrastructural concerns.

Implementation of Onion Architecture

The drawback of this traditional architecture is unnecessary coupling. Onion Architecture is based on the inversion of control principle. Onion Architecture is comprised of multiple concentric layers interfacing each other towards the core that represents the domain. The architecture does not depend on the data layer as in classic multi-tier architectures, but on the actual domain models.

The more involved approach is to define compilation modules representing the layers. Its disadvantage is a more
complicated build structure and setup of your build tool of choice. On the other side though, having the compiler on
your side is very helpful, and prevents the above-mentioned issue. The direction of the dependencies between layers is
clearly defined in the module build files. The main difference between “the classic” three-tier architecture
and the Onion, is that every outer layer sees classes from all inner layers, not only the one directly below. Moreover,
the dependency direction always goes from the outside to the inside, never the other way around.

Infrastructure Layer

One of the foundational rules of the Onion Architecture is that dependencies can only ever point inward. That is, while it is fine for the UI to reference the Application Services, it would be absolute heresy for the Domain Model to reference its services. It also gives the application the pleasant ability to be able to run without the need for real infrastructure nor delivery mechanisms as they can be swapped by mocks, which is great for testing. ContainerNinja is a boilerplate template project to demonstrate building a multi-container Full Stack application with ASP.NET Core (.NET 6) Web API following Clean Architecture, and Angular.

Also, the code is easier to test due to dependency injection, which also contributes to making the software more maintainable. There are some cases where it’s hard to fit a behavior into a single domain model.Imagine that you are modeling a banking system, where you have the Account domain model. This Architecture style does have some learning curve for developers in the project, but once mastered, pays back many
times. Finally, as with every solution in the IT industry, it is not a one-size-fits-all, and you should always consider
if the architectural style matches your needs. Onion Architecture provides several benefits, including separation of concerns, testability, maintainability, flexibility, and scalability.

Our Services

Today, we can refer to Microsoft’s platform as an onion-based architecture that is used with both ASP.NET and Visual Studio successfully. Onion architecture is a software architectural configuration to maintain libraries and dependencies on the extremities of a software system while sustaining a strong and cohesive system core. There are more examples, but hopefully, onion architecture software you get the idea. We are hiding all the implementation details in the Infrastructure layer because it is at the top of the Onion architecture, while all of the lower layers depend on the interfaces (abstractions). In the Services.Abstractions project you can find the definitions for the service interfaces that are going to encapsulate the main business logic.