Repository Pattern in .NET Core - Clean Code Architecture Guide

In the world of software development, building scalable, maintainable, and clean applications is essential. As software systems grow, the complexity of managing data access often becomes a major concern. One pattern that has proven to be an effective way to handle data access in object-oriented programming is the Repository Pattern. It is a design pattern that acts as a bridge between the domain and data mapping layers, using a collection-like interface for accessing domain objects. In this article, we will explore how the Repository Pattern fits within the .NET Core framework and how it helps in achieving clean code architecture.

Table of Contents

1. Introduction to Repository Pattern
2. Benefits of the Repository Pattern
3. Why Use the Repository Pattern in .NET Core?
4. Repository Pattern in Clean Code Architecture
5. Implementing the Repository Pattern in .NET Core
   • Setting up a Basic Project
   • Defining the Repository Interface
   • Implementing the Repository
6. Unit of Work Pattern
7. Best Practices for Implementing the Repository Pattern
8. Advanced Scenarios: Asynchronous and Pagination Support
9. Testing the Repository Layer
10. Conclusion

1. Introduction to Repository Pattern

The Repository Pattern is a structural design pattern that provides an abstraction layer between the data access code and the business logic of an application. It isolates the logic required to access data sources such as databases, web services, or file systems. This abstraction allows for cleaner and more maintainable code by decoupling business logic from data access logic.

In its simplest form, a repository acts as a collection of objects. It provides methods to add, update, remove, and query data, usually via a set of well-defined interfaces. In a typical .NET Core application, the repository interacts with an ORM (Object Relational Mapper) such as Entity Framework Core or Dapper to manage database interactions.

2. Benefits of the Repository Pattern

Implementing the repository pattern offers several key advantages:

• Abstraction: The repository abstracts away the complexities of the data access layer, making it easier to change data sources or ORM tools without affecting the business logic.
• Separation of Concerns: By separating the concerns of data access and business logic, the application becomes more modular and maintainable.
• Testability: Repositories make unit testing easier by allowing the use of mock repositories during tests instead of interacting with real databases.
• Consistency: The repository provides a consistent interface to data, regardless of the underlying data source.
• Code Reusability: The repository can be reused across multiple services and parts of the application.

3. Why Use the Repository Pattern in .NET Core?

.NET Core, being a popular framework for building modern web applications and APIs, provides several benefits for adopting the repository pattern:

• Dependency Injection: .NET Core's built-in dependency injection (DI) container makes it easy to inject repositories into service classes, promoting loose coupling and separation of concerns.
• Entity Framework Core: As the default ORM for .NET Core, Entity Framework Core can be seamlessly integrated with the repository pattern to handle database operations in an abstracted and efficient way.
• Clean Architecture: The repository pattern plays a key role in maintaining clean architecture principles, ensuring that the business logic layer is not tightly coupled to data access details.

By using the repository pattern in .NET Core, we can achieve a clean and organized architecture that is easier to manage, extend, and maintain.

4. Repository Pattern in Clean Code Architecture

The Clean Code Architecture is an approach to organizing software systems in a way that ensures the system remains flexible, maintainable, and testable. The repository pattern plays an important role in this architecture by acting as an intermediary layer between the application’s core logic and the data access layer.

In clean code architecture, we typically structure the solution with the following layers:

• Core Layer (Domain): Contains the domain models, interfaces, and business logic.
• Application Layer: Coordinates application activities, handling requests, and orchestrating the flow of data.
• Infrastructure Layer: Implements interfaces defined in the core and application layers (like data access or external service calls).
• Presentation Layer: Contains the user interface or API controllers.

By implementing the repository pattern in the infrastructure layer, we ensure that the core and application layers do not need to be aware of how data is stored or retrieved, promoting flexibility and maintainability.

5. Implementing the Repository Pattern in .NET Core

Let’s walk through the implementation of the Repository Pattern in a simple .NET Core application.

5.1 Setting up a Basic Project

First, create a new .NET Core Web API project using the following command:

dotnet new webapi -n RepositoryPatternExample
cd RepositoryPatternExample

5.2 Defining the Repository Interface

The first step in implementing the repository pattern is to define an interface that provides common methods for data access. This interface abstracts away the data access logic and provides a contract that repositories must implement.

Create a new folder called Core and inside it, define an interface IRepository.cs:

namespace RepositoryPatternExample.Core
{
    public interface IRepository<T> where T : class
    {
        Task<IEnumerable<T>> GetAllAsync();
        Task<T> GetByIdAsync(int id);
        Task AddAsync(T entity);
        Task UpdateAsync(T entity);
        Task DeleteAsync(int id);
    }
}

This generic repository interface defines basic CRUD operations (GetAllAsync, GetByIdAsync, AddAsync, UpdateAsync, DeleteAsync) for any entity type T.

5.3 Implementing the Repository

Next, implement the repository using Entity Framework Core in the Infrastructure layer. Create a folder called Infrastructure, and inside it, add a class Repository.cs that implements the IRepository interface:

using Microsoft.EntityFrameworkCore;
using RepositoryPatternExample.Core;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace RepositoryPatternExample.Infrastructure
{
    public class Repository<T> : IRepository<T> where T : class
    {
        private readonly DbContext _context;

        public Repository(DbContext context)
        {
            _context = context;
        }

        public async Task<IEnumerable<T>> GetAllAsync()
        {
            return await _context.Set<T>().ToListAsync();
        }

        public async Task<T> GetByIdAsync(int id)
        {
            return await _context.Set<T>().FindAsync(id);
        }

        public async Task AddAsync(T entity)
        {
            await _context.Set<T>().AddAsync(entity);
            await _context.SaveChangesAsync();
        }

        public async Task UpdateAsync(T entity)
        {
            _context.Set<T>().Update(entity);
            await _context.SaveChangesAsync();
        }

        public async Task DeleteAsync(int id)
        {
            var entity = await _context.Set<T>().FindAsync(id);
            if (entity != null)
            {
                _context.Set<T>().Remove(entity);
                await _context.SaveChangesAsync();
            }
        }
    }
}

This Repository class leverages the DbContext from Entity Framework Core to interact with the database. It provides the actual implementation of the methods defined in the IRepository interface.

5.4 Setting up Dependency Injection

In the Startup.cs file, configure dependency injection to inject the repository into controllers and services:

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

    services.AddScoped(typeof(IRepository<>), typeof(Repository<>));

    services.AddControllers();
}

This ensures that the repository is available for dependency injection throughout the application.

5.5 Using the Repository in Controllers

Now that the repository is set up, it can be used in the controller layer to handle HTTP requests. For example, create a ProductController that uses the repository to manage Product entities.

namespace RepositoryPatternExample.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductController : ControllerBase
    {
        private readonly IRepository<Product> _repository;

        public ProductController(IRepository<Product> repository)
        {
            _repository = repository;
        }

        [HttpGet]
        public async Task<ActionResult<IEnumerable<Product>>> Get()
        {
            var products = await _repository.GetAllAsync();
            return Ok(products);
        }

        [HttpGet("{id}")]
        public async Task<ActionResult<Product>> Get(int id)
        {
            var product = await _repository.GetByIdAsync(id);
            if (product == null)
                return NotFound();
            return Ok(product);
        }

        [HttpPost]
        public async Task<ActionResult> Create([FromBody] Product product)
        {
            await _repository.AddAsync(product);
            return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
        }

        [HttpPut("{id}")]
        public async Task<ActionResult> Update(int id, [FromBody] Product product)
        {
            if (id != product.Id)
                return BadRequest();

            await _repository.UpdateAsync(product);
            return NoContent();
        }

        [HttpDelete("{id}")]
        public async Task<ActionResult> Delete(int id)
        {
            await _repository.DeleteAsync(id);
            return NoContent();
        }
    }
}

In this example, the ProductController interacts with the IRepository<Product> to handle CRUD operations for the Product entity.

6. Unit of Work Pattern

Often used in conjunction with the Repository Pattern, the Unit of Work pattern ensures that multiple repository operations are treated as a single transaction. This pattern coordinates the writing of changes to the database.

7. Best Practices for Implementing the Repository Pattern

• Use Dependency Injection: Always inject repositories into your controllers or services, rather than directly instantiating them. This ensures better testability and adherence to the Dependency Inversion Principle.
• Avoid Overusing the Repository: The Repository Pattern is useful for handling simple CRUD operations. For more complex queries, consider using CQRS (Command Query Responsibility Segregation) or implementing custom repository methods.
• Keep Repositories Focused: A repository should only handle data access, not business logic. Keep business rules in service classes to maintain separation of concerns.

8. Advanced Scenarios: Asynchronous and Pagination Support

In a modern API, handling large amounts of data efficiently is crucial. Implementing asynchronous methods and adding pagination support can optimize performance and provide a better user experience. Consider implementing GetPagedAsync in your repository.

9. Testing the Repository Layer

Unit tests are essential to ensure that the repository works correctly. Use mocking frameworks like Moq to mock database contexts and test repository methods.

10. Conclusion

The Repository Pattern is a fundamental design pattern in building clean, maintainable applications in .NET Core. By abstracting data access and promoting separation of concerns, it allows for better testing, easier maintenance, and scalability. When used in combination with other patterns like Unit of Work, it helps developers build robust and flexible applications that can evolve over time. Implementing repositories effectively is key to adopting clean architecture principles in .NET Core, ensuring that your applications remain clean, modular, and maintainable.