Unit Of Work with Generic Repository implementation using .NET Core 6 Web API

We are going to discuss the Unit of work design pattern with the help of a generic repository and step-by-step implementation using .NET Core 6 Web API.

Agenda

• Repository Pattern
• Unit of Work
• Step-by-step Implementation

Prerequisites

• Visual Studio 2022
• SQL Server
• .NET Core 6 SDK

Repository Pattern

• The repository pattern is used to create an abstraction layer between the data access layer and the business layer of an application
• This pattern helps to reduce code duplication and follows the DRY principle.
• It also helps to create loose coupling between multiple components, when we want to change something inside the data access layer that time does not need to change another layer where we consume that functionality.
• Separation of concern makes things easier to maintain the code.
• Implementing repository patterns helps us write unit test cases efficiently and easily.

Unit of Work

• Repository pattern helps us create an abstraction, decouple the code, and avoid redundant code.

Fig- diagram is from Microsoft technical documentation

• But sometimes it could partially update data because when the application is huge and repositories share the same database context throughout the application and perform operations like insert, update and read. So, in that case, there might be a chance fail some transactions and few are executed successfully due to concurrency issues. So, for this reason, we use a unit of work to maintain the data integrity inside the application.
• Also, the unit of work manages an in-memory database when we perform CRUD operations on some entity classes as one transaction and if there are some database operations will fail then that case all operations will roll back.
• It also helps to make layers loosely coupled using dependency injection and follow Test Driven Development (TDD) principles.

Step-by-step Implementation

Step 1

Create a new .NET Core Web API

Step 2

Configure your application

Step 3

Provide some additional details

Project Structure

Step 4

Create three class library projects inside the main solution

Step 5

Next, add one model class inside the UnitOfWorkDemo.Core project and also add some interfaces.

ProductDetails.cs

IGenericRepository.cs

IProductRepository.cs

IUnitOfWork.cs

Step 6

Now, we are going to add an implementation of all repositories that we created earlier and also create one DbContextClass inside that.

Project file

GenericRepository.cs

ProductRepository.cs

UnitOfWork.cs

DbContextClass.cs

After that, create one extension class for which we are used to registering DI services, and configure that inside the Program.cs file inside the root project.

ServiceExtension.cs

Next, add migration and update the database inside the infrastructure project using the following command

add-migration “v1”
update-database

Step 5

Next, create a product service inside the Services project which we inject and consume inside the main controller

IProductService.cs

ProductService.cs

Step 6

Now, we create a Products Controller inside the main project and add multiple endpoints.

ProductsController.cs

Also, add a database connection string inside the appsetting.json file

After that, register some services inside the Program class

Finally, run the project

GitHub URL

https://github.com/Jaydeep-007/UnitOfWorkDemo

Conclusion

Here we discussed repository patterns and units of work. also, the benefits and step-by-step implementation using .NET Core Web API.

Happy Coding!