Understanding Repository Pattern in ASP.NET Core: A Comprehensive Guide with Examples

The Repository Pattern is a widely adopted design pattern that promotes loose coupling between the application's data access layer and the business logic layer. It acts as an abstraction layer over the data access code, providing a more flexible and maintainable approach to data access operations. In the context of ASP.NET Core, the Repository Pattern can be effectively implemented to enhance code organization, testability, and scalability.

What is the Repository Pattern?

The Repository Pattern is inspired by the real-world concept of a repository, which is a centralized location where entities (objects) are stored and retrieved. In software development, a repository represents a layer that encapsulates the logic required to access and manipulate data from a data source, such as a database, web service, or file system.

The main objectives of the Repository Pattern are:

1. Separation of Concerns: The Repository Pattern separates the data access logic from the business logic, promoting a more modular and maintainable codebase.
2. Abstraction: Repositories provide a higher-level abstraction over the data access layer, hiding the complexities of data access operations from the consuming components.
3. Testability: By isolating the data access logic, repositories make it easier to write unit tests for the business logic without involving the actual data source.
4. Centralized Data Access: Repositories centralize the data access operations, making it easier to manage and maintain the data access code.

Implementing the Repository Pattern in ASP.NET Core

We can implement the Repository Pattern in two different ways:

1. Specific Repository
2. Generic Repository

Specific Repository

To implement the Repository Pattern in ASP.NET Core, you'll need to create a separate project or folder structure to encapsulate the repository interfaces and their corresponding implementations. Here's a step-by-step guide to help you get started:

1. Define the Repository Interface: Start by creating an interface that defines the contract for your repository. This interface should declare the methods required for data access operations, such as retrieval, creation, update, and deletion.

public interface IProductRepository
{
    Task<IEnumerable<Product>> GetAllAsync();
    Task<Product> GetByIdAsync(int id);
    Task AddAsync(Product product);
    Task UpdateAsync(Product product);
    Task DeleteAsync(int id);
}

2. Implement the Repository: Create a concrete implementation of the repository interface that interacts with the data source (e.g., database, web service, or file system). This implementation should handle the actual data access logic.

public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _dbContext;
 
    public ProductRepository(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }
 
    public async Task<IEnumerable<Product>> GetAllAsync()
    {
        return await _dbContext.Products.ToListAsync();
    }
 
    public async Task<Product> GetByIdAsync(int id)
    {
        return await _dbContext.Products.FindAsync(id);
    }
 
    public async Task AddAsync(Product product)
    {
        _dbContext.Products.Add(product);
        await _dbContext.SaveChangesAsync();
    }
 
    public async Task UpdateAsync(Product product)
    {
        _dbContext.Products.Update(product);
        await _dbContext.SaveChangesAsync();
    }
 
    public async Task DeleteAsync(int id)
    {
        var product = await _dbContext.Products.FindAsync(id);
        if (product != null)
        {
            _dbContext.Products.Remove(product);
            await _dbContext.SaveChangesAsync();
        }
    }
}

In this example, the ProductRepository class implements the IProductRepository interface and interacts with the ApplicationDbContext to perform data access operations on the Products entity.

3. Register the Repository: In your ASP.NET Core application, you'll need to register the repository implementation with the dependency injection container. This can be done in the ConfigureServices method of your Startup class (or Program.cs file in newer versions of ASP.NET Core).

//Add DbContext Service
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
 
//Add Repository Services
builder.Services.AddScoped<IProductRepository, ProductRepository>();

4. Consume the Repository: In your controllers, services, or other components, you can inject the repository interface and use its methods to perform data access operations.

public class ProductsController : Controller
{
    private readonly IProductRepository _productRepository;
 
    public ProductsController(IProductRepository productRepository)
    {
        _productRepository = productRepository;
    }
 
    [HttpGet]
    public async Task<IActionResult> Index()
    {
        var products = await _productRepository.GetAllAsync();
        return View(products);
    }
 
    [HttpGet]
    public async Task<Product> GetProductById(int productId)
    {
        return await _productRepository.GetByIdAsync(productId);
    }
 
    [HttpPost]
    public async Task AddProduct([FromBody] Product product)
    {
        await _productRepository.AddAsync(product);
    }
 
    [HttpPut]
    public async Task UpdateProduct([FromBody] Product product)
    {
        await _productRepository.UpdateAsync(product);
    }
 
    [HttpDelete]
    public async Task DeleteProduct(int productId)
    {
        await _productRepository.DeleteAsync(productId);
    }
}

By following this approach, you decouple the data access logic from the business logic and promote a more modular and maintainable codebase. The repository pattern also makes it easier to switch data sources or implement caching mechanisms without modifying the consuming components.

Generic Repository

To further enhance code reusability and simplify the repository implementation, you can create a generic repository that can work with any entity type. Here's an example implementation of a generic repository:

1. Define the Generic Repository Interface:

public interface IGenericRepository<TEntity> where TEntity : class
{
    Task<IEnumerable<TEntity>> GetAllAsync();
    Task<TEntity> GetByIdAsync(int id);
    Task AddAsync(TEntity entity);
    Task UpdateAsync(TEntity entity);
    Task DeleteAsync(int id);
}

2. Implement the Generic Repository:

public class GenericRepository<TEntity> : IGenericRepository<TEntity> where TEntity : class
{
    private readonly ApplicationDbContext _dbContext;
    private readonly DbSet<TEntity> _dbSet;
 
    public GenericRepository(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
        _dbSet = _dbContext.Set<TEntity>();
    }
 
    public async Task<IEnumerable<TEntity>> GetAllAsync()
    {
        return await _dbSet.ToListAsync();
    }
 
    public async Task<TEntity> GetByIdAsync(int id)
    {
        return await _dbSet.FindAsync(id);
    }
 
    public async Task AddAsync(TEntity entity)
    {
        await _dbSet.AddAsync(entity);
        await _dbContext.SaveChangesAsync();
    }
 
    public async Task UpdateAsync(TEntity entity)
    {
        _dbSet.Update(entity);
        await _dbContext.SaveChangesAsync();
    }
 
    public async Task DeleteAsync(int id)
    {
        var entity = await _dbSet.FindAsync(id);
        if (entity != null)
        {
            _dbSet.Remove(entity);
            await _dbContext.SaveChangesAsync();
        }
    }
}

3. Register the Generic Repository:

//Add DbContext Service
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
 
//Add Generic Repository Services
builder.Services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));

4. Consume the Generic Repository:

public class ProductsController : Controller
{
    private readonly IGenericRepository<Product> _productRepository;
 
    public ProductsController(IGenericRepository<Product> productRepository)
    {
        _productRepository = productRepository;
    }
 
    [HttpGet]
    public async Task<IActionResult> Index()
    {
        var products = await _productRepository.GetAllAsync();
        return View(products);
    }
 
    [HttpGet]
    public async Task<Product> GetProductById(int productId)
    {
        return await _productRepository.GetByIdAsync(productId);
    }
 
    [HttpPost]
    public async Task AddProduct([FromBody] Product product)
    {
        await _productRepository.AddAsync(product);
    }
 
    [HttpPut]
    public async Task UpdateProduct([FromBody] Product product)
    {
        await _productRepository.UpdateAsync(product);
    }
 
    [HttpDelete]
    public async Task DeleteProduct(int productId)
    {
        await _productRepository.DeleteAsync(productId);
    }
}

By using a generic repository, you can reduce code duplication and provide a consistent interface for working with different entity types. This approach can further improve code organization and maintainability.

The Repository Pattern in ASP.NET Core offers numerous benefits, including better code organization, improved testability, and enhanced flexibility in managing data access operations. By separating concerns and abstracting data access logic, the Repository Pattern promotes a more modular and maintainable codebase, making it easier to adapt to changing requirements and evolving data sources. 

Hope now you have complete understanding about the Repository Pattern. Thanks for reading the article!