This slide will explain you the concept of loosely coupled architectures and how we can use Onion Architecture to create Large Scape Project based on this template

1. Project Onion
Project Architecture
By Abhinav Jha
Created On: 7th March 2018

2. What Is Onion Architecture?
The Onion Architecture term was coined by Jeffrey Palermo in 2008.
This architecture provides a better way to build applications for better testability,
maintainability, and dependability on the infrastructures like databases and
services.
This architecture's main aim is to address the challenges faced with 3-tier
architecture or n-tier architecture, and to provide a solution for common problems,
like coupling and separation of concerns. There are two types of coupling - tight
coupling and loose coupling.
This architecture relies heavily on the Dependency Inversion Principle.

3. Tight Coupling
When a class is dependent on a concrete dependency, it is said to be tightly
coupled to that class.
A tightly coupled object is dependent on another object; that means changing one
object in a tightly coupled application, often requires changes to a number of other
objects.
It is not difficult when an application is small but in an enterprise level application,
it is too difficult to make the changes.

4. Loose Coupling
It means two objects are independent and an object can use another object
without being dependent on it.
It is a design goal that seeks to reduce the inter-dependencies among components
of a system with the goal of reducing the risk that changes in one component will
require changes in any other component.

5. Layering
This is 4 layer architecture.
Type Project Name
API Layer ProjectOnion.Http
Business Layer ProjectOnion.Service
Repository Layer ProjectOnion.Repository
Middleware ProjectOnion.MongoDB
Domain Entity ProjectOnion.Model

6. Data Flow Diagram
Public Layer Private Layer
API Controllers
API Loggers
View Models
Business Logic
Utility Services
Data
Manipulator
Data
Provider
Models
Utilities
Constants
ProjectOnion.Http
Middlewares
ProjectOnion.Model
ProjectOnion.Repository
ProjectOnion.MongoDB
ProjectOnion.Service

7. Implement Onion Architecture
To implement the Onion Architecture in the ASP.NET Core application, create five
projects as described in the above section. These five projects represent five layers
of the onion architecture. Let’s see each one by one.

8. Domain Entities Layer ProjectOnion.Model
This is Infrastructure Layer for all the projects in the service and repository.
What are the things this layer contains?
Entity
Interfaces
Base
Entity
Model
Project
Models
Global
Constant
Extensions Serializers
This is how it looks.

9. Middleware ProjectOnion.MongoDB
This is the layer which will communicate with the database and gives you results based
on that.
What are the things this layer contains?
Mongodb Interface Mongodb Provider
This is how it looks.

10. 1. Task<IEnumerable<TEntity>> GetAll()
2. Task<TEntity> Get(Guid objectId)
3. Task<IEnumerable<TEntity>> Get(FilterDefinition<TEntity> filters)
4. Task<IEnumerable<TEntity>> Get(FilterDefinition<TEntity> filters,
FindOptions<TEntity> options)
5. Task<TEntity> Insert(TEntity entityObject)
6. Task<TEntity> Update(TEntity entityObject)
7. Task<TEntity> Upsert(TEntity entityObject)
8. Task<DeleteResult> Remove(Guid objectId)
9. void RemoveCollection()
10. Task<long> Count(TEntity instance);
Middleware Methods ProjectOnion.MongoDB

11. Repository Layer ProjectOnion.Repository
The layer is intended to create an Abstraction layer between the Middleware and
Business Logic layer of an application.
Entity
Implementation
Interfaces Repositories
This is how it looks.
We create a generic repository, which queries the data
source for the data, maps the data from the data
source to a business entity and persists changes in the
business entity to the data source.

12. 1. Task<IEnumerable<TEntity>> GetAll()
2. Task<TEntity> Get(Guid objectId)
3. Task<TEntity> Insert(TEntity entityObject)
4. Task<TEntity> Update(TEntity entityObject)
5. Task<DeleteResult> Remove(TEntity entityObject)
6. Task<long> Count(TEntity instance);
Repository Layer Methods ProjectOnion.Repository

13. Business Layer ProjectOnion.Service
The layer is intended to create an Abstraction layer between the Repository layer and
Web Api Layer of an application.
Entity
Implementation
Interfaces Repositories
This is how it looks.
It holds business logic for an entity so it’s called
business logic layer as well.

14. 1. Task<IEnumerable<TEntity>> GetAll()
2. Task<TEntity> Get(Guid objectId)
3. Task<TEntity> Insert(TEntity entityObject)
4. Task<TEntity> Update(TEntity entityObject)
5. Task<DeleteResult> Remove(TEntity entityObject)
6. Task<long> Count(TEntity instance);
Business Layer Methods ProjectOnion.Service

15. API Layer ProjectOnion.Http
This layer has an implementation of the Dependency Inversion Principle so that
application builds a loosely coupled application.
Dependencies View Models
Web API
Controllers
This is how it looks.
It communicates to internal layer via interfaces.
You can divide Web API’s into different versions.
Or even create Entity Model Conversion for
converting one model layer to another.
I have used this approach to reduce my work.

16. Dependency Injection
ProjectOnion.Http.ServiceDependencyProvider.cs
This will be the class to inject application dependencies.

17. Setting Client IP ProjectOnion.Http.EntityController.cs

18. Setting Added and Modified Date
ProjectOnion.Http.Model.cs

19. Application Startpage ProjectOnion
You will see this application start page.

20. Upcoming changes.
● Implement swagger for api documentation.
● Unit Test Environment
● Integration Test Environment
● Scenario Test Environment
● Middleware for Relational Database

21. My References
“Onion Architecture can be a default approach for building enterprise
applications.”
http://jeffreypalermo.com/blog/the-onion-architecture-part-1/
https://www.c-sharpcorner.com/article/onion-architecture-in-asp-net-core-mvc/
Find the Git Repo for Code:
https://github.com/abhinav2127/ProjectOnion
PPT Link: