Repository Design Pattern In ASP.NET MVC

Introduction

 

Why Design Pattern?

 

Traditionally, what do we do? We access our database directly, without using any middle layer or Data Access Layer (DAL).

 

Do you think this is a good approach? No, it's not! Here is why.

 

The tight coupling of the database logic in the business logic makes applications complex, tough to test, and tough to extend further. Direct access to the data in the business logic causes many problems like difficulty in completing the Unit Test of the business logic, disability to test business logic without the dependencies of external systems like a database, and a duplicate data access code throughout the business layer. I hope we now know why we need a design pattern. There are many types of design patterns but in today’s article, we will discuss repository design pattern.

 

What is a Repository Design Pattern?

 

By definition, the Repository Design Pattern in C# mediates between the domain and the data mapping layers using a collection-like interface for accessing the domain objects. Repository Design Pattern separates the data access logic and maps it to the entities in the business logic. It works with the domain entities and performs data access logic. In the Repository pattern, the domain entities, the data access logic, and the business logic talk to each other using interfaces. It hides the details of data access from the business logic.

 

Advantages of Repository Design Pattern

• Testing controllers becomes easy because the testing framework need not run against the actual database access code.
• Repository Design Pattern separates the actual database, queries and other data access logic from the rest of the application.
• Business logic can access the data object without having knowledge of the underlying data access architecture.
• Business logic is not aware of whether the application is using LINQ to SQL or ADO.NET. In the future, underlying data sources or architecture can be changed without affecting the business logic.
• Caching strategy for the data source can be centralized.
• Centralizing the data access logic, so code maintainability is easier

Non-Generics Repository Design Pattern Source Code
Generics Repository Design Pattern Source Code

Implementation

 

Let’s do it practically and see how it implements. We will take a very basic example of implementation. I have attached the code file that you can download from the above link. I try to do it step by step and explained each step so that you can understand better. I full try to make it simple, clear and understandable.

 

Step 1

 

Let’s create a simple database (BasicDb) containing a single table with the name of Product_Table. The Backup and Script file is attached simply download it and restore it in SQL. You can choose any one file for restoration.

 

Step 2

 

Create the Asp.Net MVC Project with the name of (Repository Design Pattern) screenshots are below.

 

 

Select MVC

 

 

Step 3

 

Create an Entity Framework to give the model name DataContext.

 

 

Select Entity framework designer from the database.

 

 

Select Database

 

 

Change name to (DataContext) it is optional you can keep as it is,

 

 

Select Table

 

 

Step 4

 

Create a Folder in the model folder with the name (DAL) where we will implement our repository.

 

 

Step 5

 

Create an Interface Class (IProductRepository.cs)

 

Paste this Code to IProductRepository.cs,

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Repositiory_Pattern.Models.DAL
{
    interface IProductRepository
    {
        IEnumerable<Product_Table> GetProducts();
        Product_Table GetProductById(int ProductId);
        void InsertProduct(Product_Table product_);
        void UpdateProduct(Product_Table product_);
        void DeleteProduct(int ProductId);
        void SaveChanges();
    }
}

IProductRepository.cs

 

Step 6

 

Create a class in the DAL folder (ProductRepository.cs) This will be child class and will implement all the methods of (IProductRepository.cs) class. Paste this Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Repositiory_Pattern.Models.DAL
{
    public class ProductRepository:IProductRepository
    {
        private DataContext _dataContext;
        public ProductRepository(DataContext dataContext)
        {
            this._dataContext = dataContext;
        }
        public void DeleteProduct(int ProductId)
        {
            Product_Table product_ = _dataContext.Product_Table.Find(ProductId);
            _dataContext.Product_Table.Remove(product_);
        }
        public Product_Table GetProductById(int ProductId)
        {
            return _dataContext.Product_Table.Find(ProductId);
        }
        public IEnumerable<Product_Table> GetProducts()
        {
            return _dataContext.Product_Table.ToList();
        }
        public void InsertProduct(Product_Table product_)
        {
            _dataContext.Product_Table.Add(product_);
        }
        public void SaveChanges()
        {
            _dataContext.SaveChanges();
        }
        public void UpdateProduct(Product_Table product_)
        {
         _dataContext.Entry(product_).State = System.Data.Entity.EntityState.Modified;
        }
    }
}

ProductRepository.cs

 

 

Step 7

 

Now just go to our built-in Home Controller and paste this code.

using Repositiory_Pattern.Models;
using Repositiory_Pattern.Models.DAL;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace Repositiory_Pattern.Controllers
{
    public class HomeController : Controller
    {
        private IProductRepository _productRepository;
        public HomeController()
        {
            this._productRepository = new ProductRepository(new DataContext());
        }
        public ActionResult Index()
        {
            return View(_productRepository.GetProducts());
        }
        public ActionResult Create()
        {
            return View(new Product_Table());
        }
        [HttpPost]
        public ActionResult Create(Product_Table product)
        {
            _productRepository.InsertProduct(product);
            _productRepository.SaveChanges();
            return RedirectToAction("Index");
        }
        public ActionResult Update(int Id)
        {
            return View(_productRepository.GetProductById(Id));
        }
        [HttpPost]
        public ActionResult Update(Product_Table product)
        {
            _productRepository.UpdateProduct(product);
            _productRepository.SaveChanges();
            return RedirectToAction("Index");
        }
        public ActionResult Delete(int Id)
        {
            _productRepository.DeleteProduct(Id);
            _productRepository.SaveChanges();
            return RedirectToAction("Index");
        }
    }
}

HomeController.cs

 

 

Step 8

 

Now create the views Index, Create and Update. Just right click on the method name.

 

Index.cshtml

 

 

Create.cshtml

 

Update.cshtml

 

 

Step 9

 

Open the Index view and change the action name Edit to Update and save.

 

 

Step 10

 

Now just run and see the result in the browser.

 

 

Conclusion

 

In this project, we have performed CRUD operations using the Repository design pattern. We have created a single interface (IProductRepository.cs) and implemented all their methods in (ProductRepository.cs). Now if we have multiple entities or models then will we make an interface for each entity? No

 

We will not do this whereas we will make a single Generic (IModelRepository.cs) and (ModelRepository.cs) if we have multiple models we will use only a single interface and their single implementation class. The Generic Repository Project code I have attached so you can download it from the above mention link. If you have any queries about the problem you face please comment below I will answer.

 

Don’t forget to like and share this article.