Repository Design Pattern

Repository Design Pattern separates the data access layer from the business layer by adding an additional layer of abstraction between them.

In repository pattern, business logic can access the data object without having knowledge of the underlying data access layer.


Possible use cases for repository pattern 

1. Underlying data source or data access layer need to change.

2. Hiding the complexity of data access layer. 

3. Centralized handling of the domain objects.


Implementation

Implementation of the repository pattern include following steps 

1. Create an Interface IProductRepository.

2. Add abstract methods for CRUD operation like Add(), Update(), Delete() and Get() in above interface as shown below.

  1. //Interface for product repository
  2. public interface IProductRepository
  3. {

  5.  Product Get(int Id);
  6.  void Add(Product entity);
  7.  void Update(Product entity);
  8.  void Delete(int Id);

  10. }


3. Create ProductRepository class which implements IProductRepository as shown below.

  1. //Implementation
  2. public class ProductRepository :IProductRepository
  3. {

  5.  protected readonly DbContext db;
  6.  public ProductRepository(DbContext _db)
  7.  {
  8.   db = _db;
  9.  }

  11.  public Product Get(int Id)
  12.  {
  13.   return db.Products.Find(Id);
  14.  }

  16.  public void Add(Product entity)
  17.  {
  18.   db.Products.Add(Product);
  19.  }

  21.  public void Delete(object Id)
  22.  {
  23.   Product entity = db.Products.Find(Id);

  25.   this.Remove(entity);
  26.  }

  28.  public void Update(Product entity)
  29.  {
  30.   db.Entry(entity).State = EntityState.Modified;
  31.  }
  32. }


4. You can now interact with data access layer by creating the instsnce of  ProductRepository class as shown below.

  1. IProductRepository productRepo = new ProductRepository();

  3. //add product
  4. productRepo.Add(productObject);

  6. //update product
  7. productRepo.Update(productObject)


Unit of Work in the Repository Pattern

Unit of work refer the way of executing in-memory database CRUD operations on dependent entities as one transaction. If any operation fails then entire db operations will be rollback.

Consider the following example to understand the concept 

Lets say we have two dependent repositories Product and Order, both will maintain their own instance of the DbContext and will have its own in-memory list of changes that are added,updated and deleted. In such a case, if SaveChanges of one of the repository fails and other one succeeds, it will bring inconsistency in database. 

To solve this problem, add a layer on the top of these repositories that will help to share common the instance of the DbContext. This will ensure all the changes among the dependent repositories should act as a unit of transaction that will either complete or  fail entirely with database rollback.

1. Create an interface that contains Product and Order as dependent repositories object as shown below 

  1. //Interface for unit of work repository
  2. public interface IUnitOfWork : IDisposable
  3. {
  4.  IOrderRepository Order { get; }
  5.  IProductRepository Products { get; }
  6.  int SaveChanges();
  7. }


2. Create a UnitOfWork class that implements the interface IUnitOfWork as shown below 

  1. public class UnitOfWork : IUnitOfWork
  2. {

  4.  private readonly DbContext db;
  5.  public UnitOfWork()
  6.  {
  7.   db = new DbContext();
  8.  }

  10.  private IOrderRepository _Order;
  11.  public IOrderRepository Order
  12.  {
  13.   get
  14.   {
  15.    if (this._Order == null)
  16.    {
  17.     this._Order = new OrderRepository(db);
  18.    }

  20.   return this._Order;

  22.   }
  23.  }

  25.  private IProductRepository _Products;

  27.  public IProductRepository Products
  28.  {
  29.   get
  30.   {

  32.    if (this._Products == null)
  33.    {
  34.     this._Products = new ProductRepository(db);
  35.    }

  37.   return this._Products;
  38.   }
  39.  }

  41.  public int SaveChanges()
  42.  {
  43.   return db.SaveChanges();
  44.  }
  45. }

3. Now create a instance of new layer IUnitOfWork and do the changes on their respective repositories as shown below.

  1. IUnitOfWork unitOfWork = new UnitOfWork();

  3. //add product details
  4. unitOfWork.Products.Add(productObject);
  5. //add order details
  6. productRepo.Order.Add(orderObject);

  8. unitOfWork.SaveChanges();

4. Finally call the SaveChanges method that shares a common instance of DbContext to ensure inconsistent changes should not go into the database.


Advantages of Repository pattern

1. De-couples the business logic and the data access layers that helps to change underlying data sources or architecture without affecting the business logic.

2. Code becomes easy to maintain and helps in fast integration of additional feature like data caching or analytics.







Comments

Post a Comment

Popular posts from this blog

Design Patterns

Image
Design patterns are a collection of reusable solutions to complex design problems in software development which evolved over time and widely accepted as the best way to address certain design challenges. They're more suitable when building an application prototype or working on large and complex projects. Design patterns are classified into three categories based on the type of problem they can solve  1. Creational design patterns  2. Structural  design patterns  3. Behavioral design patterns  Creational design patterns Creational design patterns are a type of design pattern that focus on creating objects in a way that is flexible, reusable, and efficient. These patterns provide a set of guidelines for creating objects and managing their lifecycle, helping to ensure that objects are created and used in a consistent and effective way.  Some most common examples of creation design patterns are  1.  Singleton pattern 2. Factory pattern 3. Abstra...
Read more

Abstract Factory Design Pattern

Abstract factory pattern is categorized under creational design pattern that focuses on families of related object creation without exposing its internal logic. In an abstract factory pattern, families of related objects are created without specifying their exact classes. It defines an interface for creating a set of related objects and allows different implementations of the factory to create different sets of related objects.  Possible use cases for abstract factory pattern  Here are some possible use cases for the Abstract Factory pattern 1. GUI Toolkits Abstract Factory pattern is frequently used in GUI toolkits, where different UI components like buttons, text boxes, and menus need to be created for different platforms such as Windows, Mac, or Linux. 2. Database Drivers Abstract Factory pattern can be used to create database drivers that support different databases like Oracle, MySQL, and SQL Server. The abstract factory can create a family of related objects like Co...
Read more

Azure Container Registry (ACR)

Image
Azure Container Registry (ACR) is a managed Docker registry service provided by Microsoft Azure. It is used to store and manage container images for use in Azure Kubernetes Service (AKS), Azure Web Apps, and other container-based services. ACR works by providing a secure and highly available repository for storing container images. It supports both public and private image repositories, which can be accessed by users with appropriate permissions. Users can push container images to the registry, and then pull them for use in their applications. How to Setup Azure Container Registry(ACR) To set up an Azure Container Registry (ACR), follow these steps 1. Log in to the Azure Portal (https://portal.azure.com/). 2. Click on the "+ Create a resource" button in the left-hand menu, and then search for "Container Registry" in the search box. 3. Click on "Container Registry" in the results and then click on the "Create" button. 4. In the "Basics" ...
Read more

Factory Design Pattern

Factory pattern is categorized under creational design pattern that focuses on object creation without exposing its internal logic. In factory pattern, objects are created without specifying its exact class. It defines an interface for creating objects, and allows subclasses to decide which class of object to create.  Possible use cases for factory pattern  Here are some possible use cases for the Factory pattern 1. Object creation with a common interface  If you need to create multiple objects that implement a common interface, a factory pattern can be used to abstract the creation of the objects. 2. Object creation with complex initialization  If object creation involves complex initialization, a factory pattern can be used to abstract the initialization process and make it simpler. 3. Object creation with conditional logic  If object creation requires conditional logic, a factory pattern can be used to encapsulate the logic in a factory method, making it easi...
Read more

What is Azure DevOps?

Azure DevOps is a set of practices that collaborate development(Dev) and operation(Ops) team to work closely along with the tools which are optimized for this collaboration aiming to increase the ability to develop applications faster than the traditional software development process.  DevOps lifecycle includes initial software planning, code, build, test, release phases, operations, ongoing monitoring, customer feedback and improvement.  Components of Azure DevOps  The main components of Azure DevOps are  1. Azure DevOps Boards 2. Azure DevOps Repository  3. Azure DevOps Pipeline  4. Azure DevOps Test Plans  5. Azure Artifacts Azure DevOps boards Azure board is one of the main component of azure DevOps that helps in managing the work for the project under development. Azure DevOps board main features are  Work Item  Its a defined unit of work along with some important attributes like the type of work, its severity, estimated time to com...
Read more