Repository Pattern in ASP.NET Core: Complete Guide for Beginners

What Is the Repository Pattern?

The Repository Pattern is a software design pattern that creates a layer between the application's business logic and data access logic.

Instead of allowing controllers and services to communicate directly with Entity Framework Core, repositories act as intermediaries that handle database operations.

This approach improves maintainability, testability, and separation of concerns.

Why Use the Repository Pattern?

Without a repository layer, controllers often become responsible for querying and updating the database directly.

        public class ProductsController : Controller
        {
        private readonly ApplicationDbContext _context;

        public ProductsController(
        ApplicationDbContext context)
        {
        _context = context;
        }

        public IActionResult Index()
        {
        var products =
        _context.Products.ToList();

        return View(products);
        }
        }
    

While this works for small projects, larger applications can become difficult to maintain as more data access code is added.

Benefits of the Repository Pattern

• Improved separation of concerns.
• Easier unit testing.
• Reduced code duplication.
• Cleaner controllers and services.
• Centralized data access logic.
• Easier maintenance and scalability.

Create a Product Model

        public class Product
        {
        public int Id { get; set; }

        public string Name { get; set; } = "";

        public decimal Price { get; set; }
        }
    

Create the Repository Interface

Interfaces define the contract that repository implementations must follow.

        public interface IProductRepository
        {
        IEnumerable<Product> GetAll();

        Product? GetById(int id);

        void Add(Product product);

        void Update(Product product);

        void Delete(int id);

        void Save();
        }
    

This interface provides basic CRUD operations for products.

Create the Repository Implementation

        public class ProductRepository
        : IProductRepository
        {
        private readonly
        ApplicationDbContext _context;

        public ProductRepository(
        ApplicationDbContext context)
        {
        _context = context;
        }

        public IEnumerable<Product> GetAll()
        {
        return _context.Products.ToList();
        }

        public Product? GetById(int id)
        {
        return _context.Products
        .FirstOrDefault(
        p => p.Id == id);
        }

        public void Add(Product product)
        {
        _context.Products.Add(product);
        }

        public void Update(Product product)
        {
        _context.Products.Update(product);
        }

        public void Delete(int id)
        {
        var product =
        GetById(id);

        if (product != null)
        {
        _context.Products
        .Remove(product);
        }
        }

        public void Save()
        {
        _context.SaveChanges();
        }
        }
    

Register the Repository

Register the repository inside Program.cs using Dependency Injection.

        builder.Services.AddScoped
        <IProductRepository,
        ProductRepository>();
    

ASP.NET Core will automatically inject the repository when needed.

Using the Repository in a Controller

        public class ProductsController
        : Controller
        {
        private readonly
        IProductRepository
        _repository;

        public ProductsController(
        IProductRepository repository)
        {
        _repository = repository;
        }

        public IActionResult Index()
        {
        var products =
        _repository.GetAll();

        return View(products);
        }
        }
    

The controller no longer depends directly on Entity Framework Core.

Create Operation Example

        [HttpPost]
        public IActionResult Create(
        Product product)
        {
        if (ModelState.IsValid)
        {
        _repository.Add(product);

        _repository.Save();

        return RedirectToAction(
        "Index");
        }

        return View(product);
        }
    

Read Operation Example

        public IActionResult Details(
        int id)
        {
        var product =
        _repository.GetById(id);

        if (product == null)
        {
        return NotFound();
        }

        return View(product);
        }
    

Update Operation Example

        [HttpPost]
        public IActionResult Edit(
        Product product)
        {
        if (ModelState.IsValid)
        {
        _repository.Update(product);

        _repository.Save();

        return RedirectToAction(
        "Index");
        }

        return View(product);
        }
    

Delete Operation Example

        [HttpPost]
        public IActionResult Delete(
        int id)
        {
        _repository.Delete(id);

        _repository.Save();

        return RedirectToAction(
        "Index");
        }
    

Repository Pattern with Entity Framework Core

Entity Framework Core already implements many repository-like features. Some developers argue that EF Core itself acts as a repository and unit of work implementation.

However, many teams still use custom repositories to:

• Abstract EF Core dependencies.
• Improve testability.
• Centralize query logic.
• Support future database changes.

Async Repository Methods

Modern ASP.NET Core applications should use asynchronous database operations.

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

        public async Task SaveAsync()
        {
        await _context.SaveChangesAsync();
        }
    

Async methods improve scalability and application responsiveness.

Common Repository Structure

        Repositories/

        ├── Interfaces
        │   └── IProductRepository.cs

        ├── Implementations
        │   └── ProductRepository.cs

        Models/

        Controllers/

        Services/
    

Organizing files consistently helps maintain larger projects.

Advantages of the Repository Pattern

• Cleaner code organization.
• Easier mocking during testing.
• Reduced controller complexity.
• Reusable query methods.
• Improved maintainability.

Potential Disadvantages

• Additional complexity for small projects.
• Extra abstraction layers.
• Possible duplication of EF Core functionality.

For very small applications, a repository layer may not be necessary.

Best Practices

• Use interfaces for repositories.
• Register repositories with Dependency Injection.
• Prefer async methods.
• Keep repositories focused on data access.
• Avoid placing business logic inside repositories.
• Use meaningful method names.

Frequently Asked Questions

Is the Repository Pattern still relevant?

Yes. Many organizations continue to use repositories because they improve maintainability and testing capabilities.

Does EF Core already implement a repository pattern?

EF Core provides repository-like behavior through DbSet and DbContext. Whether to add a custom repository layer depends on project requirements.

Should repositories contain business logic?

No. Repositories should focus on data access. Business logic should typically reside in services.

Should repositories use async methods?

Yes. Async database operations are recommended for modern web applications.

Related Tutorials

• Entity Framework Core CRUD
• Dependency Injection in ASP.NET Core
• ASP.NET Core MVC Tutorial
• Entity Framework Core Migrations
• Build a REST API in ASP.NET Core
• LINQ Cheat Sheet

Conclusion

The Repository Pattern is a valuable architectural approach for managing data access in ASP.NET Core applications. By separating database logic from controllers and business services, applications become easier to maintain, test, and extend.

While not every project requires a repository layer, understanding the pattern is important for developers working on professional .NET applications. Combined with Dependency Injection and Entity Framework Core, repositories can help create clean and scalable architectures.