Implementation of Repository pattern and Unit Of Work in .NET10 - Example 2

 In this post we are going to see the example 2 of implementation of repository pattern and unit of work in .Net10. we separate the project in to four layers. 

1. Domain or Entities

2. Application or UseCase

3. Infrastructure

4. Controllers

Dependencies:

Solution Structure

Domain or Entities:

1. It is consists of Entities.
2. It is consists of Repositories and Unit Of Work Interfaces.

Application or UseCase

1. It is consists of declaration of Application Service Interfaces with public access.
2. It is consists of Implementation of Application Services with internal access,
3. Usage of Repositories in the Application Services
4. To register the services in main program, we have to declare composition root.

Infrastructure

1. Consists of implementation of Repositories and Unit Of Work with internal access, which can be changed easily,in the future so business logic wont get change, because the application layer work with abstractions.
2. To register the repositories in main program we have to declare composition root.

Controller

1. Uses the Register method from application layer and infrastructure layer.

Let we see this with example.

Domain:

Application or Use Case:

Infrastructure Layer:

Controllers:

From this article you can learn a example of how to implement the Repository pattern and Unit Of Work. 

Implementation of Repository Pattern and UnitOfWork in .NET10

In this article we are going to see the what is the repository pattern and it's usage. we will see the implementation of Repository Pattern and UnitOfWork in .NET10.

using repository pattern we can decouple the abstraction and its implementation of DB layer, we can work with abstraction the implementation of that abstraction will be change based on the requirement and we can change the DB layer easily.

Abstraction interface: Domain Layer

Now we will see the interface or abstraction of UnitOfWork.

We have a Domain class named Authors:

Authors:

Create this IRepository class in the Domain layer where it will be referred in App Layer for usage, the implementation must be in infrastructure layer.

Application Layer or UseCase Layer

AuthorService

Infrastructure Layer where the actual implementation will be it can be anything like EFCore or SQL Layer etc. for example we will see that the EF-Core example. and implementation of UnitOfWork.

UnitOfWork:

Controller Layer

We have to use the composition root for register the services in infrastructure layer. and use it in the controller layer.

From this article we can learn the repository pattern and its implementation  along with UnitOfWork in .NET10.