Generic Repository Pattern With Web-API And Entity Framework

Repository pattern represents "Don’t repeat yourself", So now, we will see how the code is avoided by repeating ourselves.

Repository Pattern?
 
In most of the applications/processes, we have to perform CRUD (Create, Read, Update and Delete) operation. A repository basically works as a bridge between logic layer and data access layer of our application
 
Benefits
  1. Centralizes data/service layer.
  2. Can adopt new changes easily
Generic Repository Pattern?

Generic Repository is a pattern by which we can use single repository for accessing the data of all models. Generally, we use one repository for one model to access all the data.

Benefits
  1. Reduce redundancy of code
  2. Force developer to work same pattern 
  3. Easy to maintain
  4. Less code so Less error 
Here, I have used -
  • Visual Studio 2015
  • Entity Framework 6.1.3 
Step 1

Create a WebAPI project and create edmx.



Configure connection string in web.config -by default it will happen while creating edmx. If you want to change, you may go and change in web.config file.

Step 2

Create a folder in Web API as repository and add interface as IRepository.cs.

IRepository 

Step 3

Create generic CRUD Interface methods.
  1. public interface IRepository < T > where T: class   
  2. {  
  3.     IEnumerable < T > GetAll();  
  4.     T GetById(object Id);  
  5.     T Insert(T obj);  
  6.     void Delete(object Id);  
  7.     T Update(T obj);  
  8.     void Save();  
  9. }  
step 4

Create Repository.cs file under Repository folder to implement the interface methods to do the CRUD operations


  1. public class Repository < T > : IRepository < T > where T: class {  
  2.     private EFDBEntities context;  
  3.     -- -- -- -- -- -- -- -- -- -- - > represent edmx context name  
  4.     private DbSet < T > dbSet;  
  5.     -- -- -- -- -- -- -- -- -- -- -- -- -- - > represent respective table to perform certain operations  
  6.     public Repository() {  
  7.         context = new EFDBEntities();  
  8.         dbSet = context.Set < T > ();  
  9.     }  
  10.     public IEnumerable < T > GetAll() -- -- -- -- -- -- -- -- -- > To get all data from respective table {  
  11.         return dbSet.ToList();  
  12.     }  
  13.     public T GetById(object id) -- -- -- -- -- -- -- -- -- -- -- -- - > To get particular row data based on id(this id field should be the primary key field) {  
  14.         return dbSet.Find(id);  
  15.     }  
  16.     public T Insert(T obj) -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- > Add new record to respectiv table {  
  17.         dbSet.Add(obj);  
  18.         Save();  
  19.         return obj;  
  20.     }  
  21.     public void Delete(object id) -- -- -- -- -- -- -- -- -- -- > Delete respective record from respective table based on primarykey id {  
  22.         T entityToDelete = dbSet.Find(id);  
  23.         Delete(entityToDelete);  
  24.     }  
  25.     public void Delete(T entityToDelete) -- -- -- -- -- -- -- -- -- > this is to record the state as detached  
  26.     while we deleting data from table {  
  27.         if (context.Entry(entityToDelete).State == EntityState.Detached) {  
  28.             dbSet.Attach(entityToDelete);  
  29.             -- -- -- -- -- -- -- -- -- -- -- -- > it add the row like in particular table, particular field, particular value has been deleted with timestamps.  
  30.         }  
  31.         dbSet.Remove(entityToDelete);  
  32.     }  
  33.     public T Update(T obj) -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- > it 's to update the existing record  {  
  34.         dbSet.Attach(obj);  
  35.         context.Entry(obj).State = EntityState.Modified;  
  36.         -- -- -- -- -- - > same to record the modified state and where, what and when  
  37.         Save();  
  38.         return obj;  
  39.     }  
  40.     public void Save() {  
  41.         try {  
  42.             context.SaveChanges();  
  43.             -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - > to keep changing the entityframe as well db  
  44.         } catch (DbEntityValidationException dbEx) {  
  45.             foreach(var validationErrors in dbEx.EntityValidationErrors) {  
  46.                 foreach(var validationError in validationErrors.ValidationErrors) {  
  47.                     System.Console.WriteLine("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);  
  48.                     -- - > you just put the log to know the errors  
  49.                 }  
  50.             }  
  51.         }  
  52.     }  
  53.     protected virtual void Dispose(bool disposing) -- -- -- -- -- -- -- - > this dispose method after very instance {  
  54.         if (disposing) {  
  55.             if (context != null) {  
  56.                 context.Dispose();  
  57.                 context = null;  
  58.             }  
  59.         }  
  60.     }  
  61. }  
Step 5

Create Controller under Coontrollers folder,

 
Getall details from table

  1. public class CompanyController: ApiController {#  
  2.     region Global Declaration  
  3.     private IRepository < Company > _Companyrepository = null;  
  4.     public CompanyController() {  
  5.         this._Companyrepository = new Repository < Company > ();  
  6.     }#  
  7.     endregion# region Company  
  8.         /// <summary>  
  9.         /// Get Company List  
  10.         /// </summary>  
  11.         /// <returns></returns>  
  12.         [Route("api/GetCompanies")]  
  13.         [HttpGet]  
  14.     public HttpResponseMessage GetCompanies() {  
  15.         var result = _Companyrepository.GetAll();  
  16.         HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, result);  
  17.         return response;  
  18.     }  
  19.     /// <summary>  
  20.     /// Get Company Detail  
  21.     /// </summary>  
  22.     /// <param name="CompanyId"></param>  
  23.     /// <returns></returns>  
  24.     [Route("api/GetCompany")]  
  25.     [HttpGet]  
  26.     public HttpResponseMessage GetCompany(int CompanyId) {  
  27.         var result = _Companyrepository.GetById(CompanyId);  
  28.         HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, result);  
  29.         return response;  
  30.     }  
  31.     /// <summary>  
  32.     /// Delete Company Detail  
  33.     /// </summary>  
  34.     /// <param name="CompanyId"></param>  
  35.     /// <returns></returns>  
  36.     [Route("api/DeleteCompany")]  
  37.     [HttpGet]  
  38.     public HttpResponseMessage DeleteCompany(int CompanyId) {  
  39.         var result = _Companyrepository.Delete(CompanyId);  
  40.         HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, result);  
  41.         return response;  
  42.     }  
  43.     /// <summary>  
  44.     /// UpdateCompany Detail  
  45.     /// </summary>  
  46.     /// <param name="CompanyId"></param>  
  47.     /// <returns></returns>  
  48.     [Route("api/UpdateCompany")]  
  49.     [HttpGet]  
  50.     public HttpResponseMessage UpdateCompany(Company CompanyDetails) {  
  51.         var result = _Companyrepository.Update(CompanyDetails);  
  52.         HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, result);  
  53.         return response;  
  54.     }#  
  55.     endregion  
  56. }  
and now, you can perform CRUD operation by calling this API.

This article introduced the generic repository pattern with Entity Framework.