Repository Design Pattern in Asp .Net

Introduction:

The Repository Design Pattern is a widely used pattern in software development. It separates the Data Access layer from Controller Layer. This pattern is important for achieving separation of concerns, flexibility, and maintainability. In this blog post, we will demonstrate how to implement the Repository Design Pattern in ASP.NET using C# code.

Step 1: Define an Interface for the Repository

The first step is to define an interface for the repository. This interface should specify the methods that will be used to access the Database (data source). In this example, we will create an interface named ICategoryRepository.

public interface ICategoryRepository
{
    IEnumerable GetAllCategories();
    Product GetCategoryById(int id);
    void AddCategory(Product product);
    void UpdateCategory(Product product);
    void DeleteCategory(int id);
}

Step 2: Implement the Repository Interface

The next step is to implement the repository interface. This implementation should contain the logic for accessing the Database (data source). In this example, we will create a class named CategoryRepository that implements the ICategoryRepository interface. We will use Entity Framework to access the data source.

public class CategoryRepository : ICategoryRepository
{
    private readonly ApplicationDbContext _dbContext;

    public CategoryRepository(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public IEnumerable GetAllCategories()
    {
        return _dbContext.Category.ToList();
    }

    public Product GetCategoryById(int id)
    {
        return _dbContext.Category.FirstOrDefault(p => p.Id == id);
    }

    public void AddCategoryDetails(Category category)
    {
        _dbContext.Category.Add(category);
        _dbContext.SaveChanges();
    }

    public void UpdateCategory(Category category)
    {
        _dbContext.Category.Update(category);
        _dbContext.SaveChanges();
    }

    public void DeleteCategory(int id)
    {
        var category = GetCategoryById(id);
        if (category != null)
        {
            _dbContext.Category.Remove(category);
            _dbContext.SaveChanges();
        }
    }
}

Step 3: Inject the Repository into the Application

The next step is to inject the repository into the application solution. We will use dependency injection to inject the repository into the application. In this example, we will add the following code to the Startup.cs file to configure dependency injection.

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext(options =>
        options.UseSqlServer(Configuration.GetConnectionString("Default")));

    services.AddScoped();

    services.AddControllersWithViews();
}

Step 4: Use the Repository in the Application

The final step is to use the repository in the controller layer. We will use the repository in a controller to fetch and modify the data. In this example, we will create a controller named CategoryController that uses the ICategoryRepository interface.

public class CategoryController : Controller
{
    private readonly ICategoryRepository _categoryRepository;

    public CategoryController(ICategoryRepository categoryRepository)
    {
        _categoryRepository = categoryRepository;
    }

    public IActionResult Index()
    {
        var category = _categoryRepository.GetAllCategories();
        return View(category);
    }

    public IActionResult Details(int id)
    {
        var category = _categoryRepository.GetcategoryById(id);
    
        if (category == null) {
            return NotFound();
        }
        return View(category);
        }

    [HttpGet]
    public IActionResult Create()
    {
        return View();
    }

    [HttpPost]
    public IActionResult Create(Category category)
    {
        if (ModelState.IsValid)
            {
        _categoryRepository.AddCategory(category);
        return RedirectToAction(nameof(Index));
        }
    return View(category);
    }

[HttpGet]
public IActionResult Edit(int id)
{
    var category = _categoryRepository.GetCategoryById(id);
    if (category == null)
    {
        return NotFound();
    }
    return View(category);
    }

[HttpPost]
public IActionResult Edit(int id, Category category)
{
    if (id != category.Id)
    {
        return NotFound();
    }

    if (ModelState.IsValid)
    {
        _categoryRepository.UpdateCategory(category);
        return RedirectToAction(nameof(Index));
    }
    return View(category);
    }

[HttpGet]
public IActionResult Delete(int id)
{
    var category = _categoryRepository.GetCategoryById(id); 
    if (category == null)
    {
        return NotFound();
    }
    return View(category);
    }

Benefits of using Repository Design Pattern in ASP.NET:

Decoupling (Improved Separation of Concerns): The Repository Design Pattern separates the data access logic from the application logic.

Flexibility: The Repository Design Pattern provides a flexible architecture for data access, making it easy to change the data source without affecting the application logic.

Maintainability: The Repository Design Pattern makes it easier to maintain the application by isolating the data access logic as a separate layer.

Performance: The Repository Design Pattern can improve the performance of the application by reducing the number of trips to the database.

Conclusion:

The Repository Design Pattern is an important pattern in software development. It provides a scalable and maintainable architecture for data access in ASP.NET. By separating the data access logic from the application logic, the Repository Design Pattern achieves decoupling, flexibility, maintainability, and application performance.