Why to use repository pattern in c#

Using the Repository Pattern in ASP.NET MVC 4.8

Using the Repository Pattern in ASP.NET MVC 4.8 allows for a more structured, testable, and maintainable codebase by abstracting data access logic. Below is a step-by-step guide on how to implement the Repository Pattern in an MVC 4.8 application using a User entity as an example.

Steps to Implement the Repository Pattern in MVC 4.8

• Create the Models: Define the User entity.
• Create the Repository Interface: Define an interface for the repository with the methods you need (e.g., GetUserById, AddUser).
• Implement the Repository: Create a concrete class that implements the repository interface.
• Create the Service Layer: Optionally, create a service layer to abstract the repository logic.
• Use Dependency Injection: Since native dependency injection isn't available in MVC 4, use a third-party library like Unity or Ninject, or manually inject dependencies.
• Use the Repository in the Controller: Inject the repository/service into your controller and use it to interact with the data.

1. Create the Models Models/User.cs:

   
     using System.ComponentModel.DataAnnotations;
     namespace YourNamespace.Models
     {
     public class User
     {
     public int Id { get; set; }
     [Required]
     public string Name { get; set; }
     [Required]
     [EmailAddress]
     public string Email { get; set; }
     // Additional properties
     }
     }
    

2. Create the Repository Interface Repositories/IUserRepository.cs:

      using System.Collections.Generic;
      using YourNamespace.Models;
      namespace YourNamespace.Repositories
      {
      public interface IUserRepository
      {
      User GetUserById(int id);
      IEnumerable
     GetAllUsers();
     void AddUser(User user);
     void UpdateUser(User user);
     void DeleteUser(int id);
     }
     }
     

3. Implement the Repository Repositories/UserRepository.cs:

     using System.Collections.Generic;
     using System.Linq;
     using YourNamespace.Models;

     namespace YourNamespace.Repositories
     {
     public class UserRepository : IUserRepository
     {
     private readonly ApplicationDbContext _context;

     public UserRepository(ApplicationDbContext context)
     {
     _context = context;
     }
     public User GetUserById(int id)
     {
     return _context.Users.Find(id);
     }
     public IEnumerable
     GetAllUsers()
     {
     return _context.Users.ToList();
     }
     public void AddUser(User user)
     {
     _context.Users.Add(user);
     _context.SaveChanges();
     }
     public void UpdateUser(User user)
     {
     _context.Entry(user).State = System.Data.Entity.EntityState.Modified;
     _context.SaveChanges();
     }
     public void DeleteUser(int id)
     {
     var user = _context.Users.Find(id);
     if (user != null)
     {
     _context.Users.Remove(user);
     _context.SaveChanges();
     }
     }
     }
     }   
                        

4. (Optional) Create the Service Layer To further abstract the repository, you can create a service layer.

     Services/IUserService.cs:    
    
     using System.Collections.Generic;
     using YourNamespace.Models;

     namespace YourNamespace.Services
     {
     public interface IUserService
     {
     User GetUserById(int id);
     IEnumerable
     GetAllUsers();
     void AddUser(User user);
     void UpdateUser(User user);
     void DeleteUser(int id);
     }
     }
     Services/UserService.cs:     
     
     using System.Collections.Generic;
     using YourNamespace.Models;
     using YourNamespace.Repositories;

     namespace YourNamespace.Services
     {
     public class UserService : IUserService
     {
     private readonly IUserRepository _userRepository;

     public UserService(IUserRepository userRepository)
     {
     _userRepository = userRepository;
     }
     public User GetUserById(int id)
     {
     return _userRepository.GetUserById(id);
     }
     public IEnumerable
     GetAllUsers()
     {
     return _userRepository.GetAllUsers();
     }
     public void AddUser(User user)
     {
     _userRepository.AddUser(user);
     }
     public void UpdateUser(User user)
     {
     _userRepository.UpdateUser(user);
     }
     public void DeleteUser(int id)
     {
     _userRepository.DeleteUser(id);
     }
     }
     }   

5. Set Up Dependency Injection ASP.NET MVC 4 does not have built-in dependency injection, so you need to use a third-party DI container like Unity or Ninject. Here’s how you can set up Unity.

Step a: Install Unity via NuGet

      bash     
      Install-Package Unity.Mvc4
      

Step b: Configure Unity in App_Start/UnityConfig.cs

     using Microsoft.Practices.Unity;
     using System.Web.Mvc;
     using Unity.Mvc4;
     using YourNamespace.Repositories;
     using YourNamespace.Services;

     namespace YourNamespace
     {
     public static class UnityConfig
     {
     public static void RegisterComponents()
     {
     var container = new UnityContainer();

     container.RegisterType< IUserRepository, UserRepository> ();
     container.RegisterType< IUserService, UserService> ();
     DependencyResolver.SetResolver(new UnityDependencyResolver(container));
     }
     }
     }
     

Step c: Call RegisterComponents() in Global.asax

     protected void Application_Start()
     {
     UnityConfig.RegisterComponents();
     AreaRegistration.RegisterAllAreas();
     FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
     RouteConfig.RegisterRoutes(RouteTable.Routes);
     BundleConfig.RegisterBundles(BundleTable.Bundles);
     }
     

6. Use the Repository in the Controller Now, you can inject the IUserService or IUserRepository directly into your controllers.

     Controllers/UserController.cs:   
    
     using System.Web.Mvc;
     using YourNamespace.Models;
     using YourNamespace.Services;

     namespace YourNamespace.Controllers
     {
     public class UserController : Controller
     {
     private readonly IUserService _userService;

     public UserController(IUserService userService)
     {
     _userService = userService;
     }

     public ActionResult Index()
     {
     var users = _userService.GetAllUsers();
     return View(users);
     }

     public ActionResult Details(int id)
     {
     var user = _userService.GetUserById(id);
     if (user == null)
     {
     return HttpNotFound();
     }
     return View(user);
      }

      public ActionResult Create()
      {
      return View();
      }

      [HttpPost]
      public ActionResult Create(User user)
      {
      if (ModelState.IsValid)
      {
      _userService.AddUser(user);
      return RedirectToAction("Index");
      }
      return View(user);
      }

      public ActionResult Edit(int id)
      {
      var user = _userService.GetUserById(id);
      if (user == null)
      {
      return HttpNotFound();
      }
      return View(user);
      }

      [HttpPost]
      public ActionResult Edit(User user)
      {
      if (ModelState.IsValid)
      {
      _userService.UpdateUser(user);
      return RedirectToAction("Index");
      }
      return View(user);
      }

      public ActionResult Delete(int id)
      {
      var user = _userService.GetUserById(id);
      if (user == null)
      {
      return HttpNotFound();
      }
      return View(user);
      }

      [HttpPost, ActionName("Delete")]
      public ActionResult DeleteConfirmed(int id)
      {
      _userService.DeleteUser(id);
      return RedirectToAction("Index");
      }
      }
      }

Unit of Work pattern

The Unit of Work pattern is commonly used in conjunction with the Repository pattern to manage transactions and maintain consistency in your database operations. The Unit of Work pattern ensures that multiple operations can be treated as a single transaction, allowing for commit or rollback operations if any part of the transaction fails.

Why Use Unit of Work with Repository Pattern?

Consistency: Ensures that all operations within a transaction either complete successfully or none of them do.
Decoupling: Separates the logic of business transactions from the persistence layer.
Efficiency: Manages changes across multiple repositories, preventing unnecessary database calls.

Summary

This Article demonstrates how to implement the Repository Pattern in an ASP.NET MVC 4.8 application, including how to set up the repository, optionally use a service layer, and configure dependency injection using Unity. This structure will help in creating a more maintainable, testable, and scalable MVC application.Using the Repository Pattern in ASP.NET MVC 4.8 allows for a more structured, testable, and maintainable codebase by abstracting data access logic.

---