Explaining ASP.NET Core EF Core with Repository Pattern in Detail

Introduction

Developing web applications today requires a structured and maintainable codebase. ASP.NET Core, Microsoft's modern web framework, combined with Entity Framework Core (EF Core), Microsoft's data access technology, provides a powerful setup for database management. Adding the Repository Pattern on top of these technologies enhances modularity and separation of concerns, facilitating better maintenance, testing, and scalability.

In this guide, we'll walk through how to implement the Repository Pattern in an ASP.NET Core application using EF Core. This involves setting up the project, configuring EF Core, creating a repository interface and its implementation, and integrating it into the application. Let’s begin!

Step 1: Setting Up the ASP.NET Core Project

1. Create a New ASP.NET Core Project: First, open Visual Studio (or any other preferred IDE) and create a new ASP.NET Core Web Application project.

   • Go to File > New > Project.
   • Select ASP.NET Core Web Application and click Next.
   • Name your project and choose the location.
   • Click Next.
   • Select the project type. For simplicity, choose Web Application (Model-View-Controller).
   • Click Create.

2. Install EF Core NuGet Packages: After creating the project, you need to add EF Core NuGet packages. You can do this via the NuGet Package Manager:

   • Right-click on your project in the Solution Explorer and go to Manage NuGet Packages.
   • In the "Browse" tab, search for and install the following packages:
     • Microsoft.EntityFrameworkCore
     • Microsoft.EntityFrameworkCore.SqlServer
     • Microsoft.EntityFrameworkCore.Tools
   • These packages provide the necessary functionality for EF Core and SQL Server integration.

Step 2: Configuring Entity Framework Core

1. Define the Model: Models in ASP.NET Core represent the structure of your data. For this example, let's create a simple Blog entity.

   public class Blog
   {
       public int BlogId { get; set; }
       public string Url { get; set; }
       public string Description { get; set; }
   }
   

2. Create the DbContext: A DbContext is a bridge between your code and the database. It manages entity objects, persisting changes to the database, and retrieving data from queries.

   using Microsoft.EntityFrameworkCore;
   
   public class BloggingContext : DbContext
   {
       public BloggingContext(DbContextOptions<BloggingContext> options)
           : base(options)
       {
       }
   
       public DbSet<Blog> Blogs { get; set; }
   }
   

3. Register DbContext in Startup.cs: Configure your application to use the DbContext. This involves registering it in the dependency injection container. In ASP.NET Core 3.0 and later, this configuration is done in Program.cs, while in earlier versions, it's done in Startup.cs.

   var builder = WebApplication.CreateBuilder(args);
   
   // Add services to the container.
   builder.Services.AddControllersWithViews();
   
   builder.Services.AddDbContext<BloggingContext>(options =>
       options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
   
   var app = builder.Build();
   
   // Configure the HTTP request pipeline.
   if (!app.Environment.IsDevelopment())
   {
       app.UseExceptionHandler("/Home/Error");
       app.UseHsts();
   }
   
   app.UseHttpsRedirection();
   app.UseStaticFiles();
   
   app.UseRouting();
   
   app.UseAuthorization();
   
   app.MapControllerRoute(
       name: "default",
       pattern: "{controller=Home}/{action=Index}/{id?}");
   
   app.Run();
   

   Ensure you add the connection string in appsettings.json:

   "ConnectionStrings": {
     "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=Blogging;Trusted_Connection=True;MultipleActiveResultSets=true"
   }
   

Step 3: Implementing the Repository Pattern

1. Create the Repository Interface: A repository interface acts as a layer of abstraction between the data source and the business logic.

   public interface IRepository<TEntity> where TEntity : class
   {
       IEnumerable<TEntity> GetAll();
       TEntity GetById(int id);
       void Add(TEntity entity);
       void Update(TEntity entity);
       void Delete(TEntity entity);
   }
   

2. Create the Repository Implementation: The repository implementation interacts directly with the DbContext to perform CRUD operations.

   public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
   {
       private readonly BloggingContext _context;
       private DbSet<TEntity> _dbSet;
   
       public Repository(BloggingContext context)
       {
           _context = context;
           _dbSet = context.Set<TEntity>();
       }
   
       public IEnumerable<TEntity> GetAll()
       {
           return _dbSet.ToList();
       }
   
       public TEntity GetById(int id)
       {
           return _dbSet.Find(id);
       }
   
       public void Add(TEntity entity)
       {
           _dbSet.Add(entity);
           _context.SaveChanges();
       }
   
       public void Update(TEntity entity)
       {
           _dbSet.Update(entity);
           _context.SaveChanges();
       }
   
       public void Delete(TEntity entity)
       {
           _dbSet.Remove(entity);
           _context.SaveChanges();
       }
   }
   

Step 4: Integrating Repository Pattern with Dependency Injection

1. Register Repository in Startup.cs: Register the repository implementation in the dependency injection container so that it can be injected into controllers and other services.

   builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
   

2. Inject Repository into Controllers: Inject the repository into your controllers via the constructor. This allows you to perform CRUD operations on the Blog entity without directly interacting with the DbContext.

   public class BlogController : Controller
   {
       private readonly IRepository<Blog> _blogRepository;
   
       public BlogController(IRepository<Blog> blogRepository)
       {
           _blogRepository = blogRepository;
       }
   
       public IActionResult Index()
       {
           var blogs = _blogRepository.GetAll();
           return View(blogs);
       }
   
       public IActionResult Details(int id)
       {
           var blog = _blogRepository.GetById(id);
           if (blog == null)
           {
               return NotFound();
           }
           return View(blog);
       }
   
       public IActionResult Create()
       {
           return View();
       }
   
       [HttpPost]
       [ValidateAntiForgeryToken]
       public IActionResult Create([Bind("BlogId,Url,Description")] Blog blog)
       {
           if (ModelState.IsValid)
           {
               _blogRepository.Add(blog);
               return RedirectToAction(nameof(Index));
           }
           return View(blog);
       }
   
       public IActionResult Edit(int id)
       {
           var blog = _blogRepository.GetById(id);
           if (blog == null)
           {
               return NotFound();
           }
           return View(blog);
       }
   
       [HttpPost]
       [ValidateAntiForgeryToken]
       public IActionResult Edit(int id, [Bind("BlogId,Url,Description")] Blog blog)
       {
           if (id != blog.BlogId)
           {
               return NotFound();
           }
   
           if (ModelState.IsValid)
           {
               _blogRepository.Update(blog);
               return RedirectToAction(nameof(Index));
           }
           return View(blog);
       }
   
       public IActionResult Delete(int id)
       {
           var blog = _blogRepository.GetById(id);
           if (blog == null)
           {
               return NotFound();
           }
   
           return View(blog);
       }
   
       [HttpPost, ActionName("Delete")]
       [ValidateAntiForgeryToken]
       public IActionResult DeleteConfirmed(int id)
       {
           var blog = _blogRepository.GetById(id);
           if (blog != null)
           {
               _blogRepository.Delete(blog);
           }
   
           return RedirectToAction(nameof(Index));
       }
   }
   

Step 5: Creating Views for CRUD Operations

For sake of brevity, I will provide an example of the Index view, but you can follow the pattern to create views for Details, Create, Edit, and Delete as well.

1. Index.cshtml:

   @model IEnumerable<YourNamespace.Models.Blog>
   
   @{
       ViewData["Title"] = "Blog List";
   }
   
   <h2>Blog List</h2>
   
   <p>
       <a asp-action="Create">Create New</a>
   </p>
   <table class="table">
       <thead>
           <tr>
               <th>
                   @Html.DisplayNameFor(model => model.Url)
               </th>
               <th>
                   @Html.DisplayNameFor(model => model.Description)
               </th>
               <th></th>
           </tr>
       </thead>
       <tbody>
   @foreach (var item in Model) {
           <tr>
               <td>
                   @Html.DisplayFor(modelItem => item.Url)
               </td>
               <td>
                   @Html.DisplayFor(modelItem => item.Description)
               </td>
               <td>
                   <a asp-action="Edit" asp-route-id="@item.BlogId">Edit</a> |
                   <a asp-action="Details" asp-route-id="@item.BlogId">Details</a> |
                   <a asp-action="Delete" asp-route-id="@item.BlogId">Delete</a>
               </td>
           </tr>
   }
       </tbody>
   </table>
   

Step 6: Testing the Application

Run your application and navigate to the /Blog route to interact with the CRUD functionalities. You can add new blogs, edit existing ones, and delete them.

Conclusion

By following these steps, you have successfully integrated the Repository Pattern in an ASP.NET Core application using EF Core. This approach provides a structured and maintainable way to manage data access, separating concerns between your business logic and data persistence logic. This architecture improves testability, modularity, and scalability of your application, making it easier to adapt to changes and manage complexity as your application grows.

Additional Tips

• Use Interfaces for Testing: The use of interfaces (like IRepository) allows you to mock data access logic during unit testing, improving test coverage and efficiency.
• Consider Async Operations: For improved performance and responsiveness, consider using async methods for data operations in your repository.
• Error Handling: Implement proper error handling and validation to make your application more robust.
• Dependency Injection: Leverage dependency injection throughout your application to manage services and dependencies efficiently.

This comprehensive guide should provide a solid foundation for implementing the Repository Pattern in ASP.NET Core applications using EF Core. Happy coding!