Dependency Injection And Repository Pattern in .Net Core MVC With Entity Framework Core

Implementing Repository + Dependency Injection in .Net core MVC with Entity framework core

In this blog I will create an application using .net Core MVC and Entity framework core, implementing Repository Pattern and Dependency Injection.

I will make the application loosely coupled as much as possible. The data access layer and UI will be completely independent of each other.

Prerequisite

Prior knowledge of MVC and Entity framework

Let’s begin.

Project Creation

I am using the Visual Studio 2019 community edition.

Open your IDE and create .net core MVC project

.Net Core MVC With Entity Framework Core Using Dependency Injection And Repository

Select Asp.Net Core Web Application and press next

Name your solution and create

Project is created.

The solution will have Controller, Model, View folder and one new wwwroot folder and a few more files named appsetting.json, Startup.cs, Program.cs.

Let’s understand what these files are.

Appsetting.json file is your web.config file.

Program.cs file is the same as in your console application and is called once for the entire application life cycle.

Startup.cs is used for configuring your .net core application.

Let us create a small module of adding product in an eCommerce website.

Model

First create a Product model in, for that we will create a new .net core class library project in the same solution

namespace ECommerce.Entity
{
[Table("Product")]
public class Product
{
[Key]
public string ProductId { get; set; }
[Required]
[MaxLength(50)]
public string ProductName { get; set; }
[MaxLength(300)]
public string ProductDescription { get; set; }
[Required]
[DisplayName("Category")]
public string CategoryId { get; set; }
[Required]
public double QuantityPerUnit { get; set; }
[Required]
public double UnitPrice { get; set; }
[Required]
public double MSRP { get; set; }
public double AvailableSize { get; set; }
public string AvailableColor { get; set; }
public double Discount { get; set; }
[Required]
public double UnitWeight { get; set; }
[Required]
public double UnitsInStock { get; set; }
public double UnitsOnOrder { get; set; }
public double ProductAvailability { get; set; }
public string Picture { get; set; }
public string Note { get; set; }
}
}

This model will be used to save data and bind view and controller.

Entity framework core Context

The next step is to create Entity framework core context. For that we create a new .net core class library project and install a nugget package in it.

Create a ECommerceContext class

namespace ECommerce.DAL
{
public class ECommerceContext : DbContext
{
public ECommerceContext(DbContextOptions<ECommerceContext> options) : base(options)
{
}
public DbSet<Category> Categories { get; set; }
public DbSet<Product> Products { get; set; }
}
}

Repository

Now let’s create a new .net core class library project named Ecommerce.IRepositories.

And create an interface in the project. This project will only contain Interfaces.

namespace ECommerce.IRepos
{
public interface IProductRepository
{
IList<Product> GetProducts();
Product GetProduct(string productId);
void Add(Product product);
Product Update(Product product);
void Delete(Product product);
}
}

Interfaces play a key role in making the application loosely coupled and more injectable.

To implement this interface we’ll create another .net core class library project for repository.

Name Ecommerce.Repositories and create a class.

namespace ECommerce.Repos
{
public class ProductRepository : IProductRepository
{
private readonly ECommerceContext productContext;
public ProductRepository(ECommerceContext context)
{
productContext = context;
}
public void Add(Product product)
{
product.ProductId = Guid.NewGuid().ToString();
productContext.Add(product);
productContext.SaveChanges();
}
public void Delete(Product product)
{
productContext.Products.Remove(product);
productContext.SaveChanges();
}
public IList<Product> GetProducts()
{
return productContext.Products.ToList();
}
public Product GetProduct(string productId)
{
return productContext.Products.FirstOrDefault(x=> x.ProductId == productId);
}
public Product Update(Product productChanges)
{
var product = productContext.Products.Attach(productChanges);
product.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
productContext.SaveChanges();
return productChanges;
}
}
}

Now, we have created our context, our model and our repository.

Application

It’s time to create a controller named ProductController.cs and inject all the dependencies in it. To inject the dependencies we need to configure startup.cs file.

Add the following code in ConfigureService method.

services.AddScoped<IProductRepository, ProductRepository>();
services.AddDbContextPool<ECommerceContext>(x => x.UseSqlServer(ConnectionString, b => b.MigrationsAssembly("ECommerce")));

The controller will look like the below code.

IProductRepository productRepo = null;
public ProductController(IProductRepository prodRepo)
{
productRepo = prodRepo;
}

As you can see we are using parameterized constructor of controller to inject the dependency.

In .net core there is built in support for dependency injection.

services.AddScoped<IProductRepository, ProductRepository>();

The above line is used to inject any dependency in controller.

The below method is used to save Product detail in database.

public ActionResult SaveProduct(Product product)
{
if (ModelState.IsValid)
{
if (string.IsNullOrEmpty(product.ProductId))
{
productRepo.Add(product);
}
else {
product = productRepo.Update(product);
}
}
return View("Create");
}

View to controller binding is the same as it was in the MVC application and I understand you guys are better at that so I'm not going through it.

Notes

If you look at the Repository class, I have injected context class in its constructor.

Summary

This is how you create a .net core MVC application with repository and dependency injection which is loosely coupled and easily configurable.

I am open to all kinds of discussion. Feel free to comment and suggest anything.

Thank you.

7 Comments

Join the conversation! Your thoughts help the community grow.

Sachin Kumar5y ago
Hello Ishoo, great article. thanks for sharing. Have you ever uploaded this to the public repo?
Robert Pantino6y ago
Hi, where can i get/download full source? anyways thanks for this article keep on posting :)
- Ishoo Anyal6y ago
  I'm glad you liked it. I'll share public repo url soon
Technology Crowds6y ago
Very Nice Article about Entity framework using dependency injection. Dependency, it is the object (or a service) which is required by a class (or a client). By using Dependency Injection, we can pass pre-defined and constructed objects to classes for processing.
Pushpam Abhishek6y ago
Nice articles.thank you https://www.trickcode.in/
- Ishoo Anyal6y ago
  You are running your own Blog related to technologies?
Judi Adu Ayam Rknslot6y ago
Nice article. Thanks you for your review