In previous
tutorial you used basic CRUD (Create, Read, Update and Delete)
functionality with entity framework and by using jquery dialog(s) in asp.net
mvc. In this you’ll see some ways to use the repository and unit of work
patterns for CRUD operations.
The repository and unit of work patterns are intended to
create an abstraction layer between the data access layer and the business
logic layer of an application. Implementing these patterns can help insulate
your application from changes in the data store and facilitate automated unit
testing or test-driven development (TDD).
Let’s start with the implementation of Repository and Unit
of Work patterns in a tutorial. If you have gone through my previous
tutorial then start with where it ends and if you do not have experience
about previous tutorial please download the sample of previous
tutorial and start with that.
1) In
the current solution, add three new class library project:
a) Sample.Model
b) Sample.Data.Contracts
c) Sample.Data
Our solution explorer will something look like this:
ManagingMultijQueryForm
Sample.Data
Sample.Data.Contracts
Sample.Model
2) Delete
Category, SubCategory and Product class from the web project i.e. ManagingMultijQueryForm
and add these classes in Sample.Model project. Also add reference of System.ComponentModel.DataAnnotations in
order to use the (Required and Display) attribute.
a) Category
class (Category.cs):
public class Category
{
public int
CategoryID { get; set; }
[Required]
public string Name
{ get; set; }
}
b) SubCategory
class (SubCategory.cs):
public class SubCategory
{
public int
SubCategoryID { get; set; }
public virtual Category
Category { get; set; }
[Display(Name
= "Category")]
public int
CategoryID { get; set; }
[Required]
public string Name
{ get; set; }
}
c) Product
class (Product.cs):
public class Product
{
public int
ProductID { get; set; }
[Required]
public string Name
{ get; set; }
[Required]
public string
Description { get; set; }
public virtual SubCategory
SubCategory { get; set; }
[Display(Name
= "Sub Category")]
public int
SubCategoryID { get; set; }
}
3) In
Sample.Data.Contracts add two interface IRepository (for repositories) and IProductUow
( for unit of work). Before creating the interfaces add the reference of Sample.Model
in Sample.Data.Contracts
a) IRepository.cs,
it is generic interface:
public interface IRepository<T>
where T: class
{
IQueryable<T>
GetAll();
T GetById(int id);
void
Add(T entity);
void
Update(T entity);
void
Delete(T entity);
void
Delete(int id);
}
b) IProductUow.cs
:
public interface IProductUow
{
//
Save pending changes to the data store.
void
Commit();
//
Repositories
IRepository<Product>
Products { get; }
IRepository<Category>
Categories { get; }
IRepository<SubCategory>
SubCategories { get; }
}
4)
In Sample.Data project, add the reference of Sample.Model and
Sample.Data.Contracts and install entity framework via package manager console (Tools
à Library Package Manager à Package Manager Console) by using
following command:
Install-package entityframework
5) Delete
ProductDbContext, ProductDbContextInitializer from the web project and add
these classes in Sample.Data project:
a) ProductDbContext
class (ProductDbContext.cs):
public class ProductDbContext : DbContext
{
public
ProductDbContext()
: base(nameOrConnectionString:
"Data Source=SONY-VAIO\\SQLEXPRESS;Initial
Catalog=ProductDbContext;Integrated Security=true;")
{
Database.SetInitializer(new ProductDbContextInitializer());
}
protected override void
OnModelCreating(DbModelBuilder modelBuilder)
{
//
Use singular table names
modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
base.OnModelCreating(modelBuilder);
}
public DbSet<Product>
Product { get; set; }
public DbSet<Category>
Category { get; set; }
public DbSet<SubCategory>
SubCategory { get; set; }
}
b) ProductDbContextInitializer
class (ProductDbContextInitializer.cs)
public class ProductDbContextInitializer : DropCreateDatabaseIfModelChanges<ProductDbContext>
{
protected override void
Seed(ProductDbContext context)
{
List<Category>
categories = new List<Category>
{
new Category {
Name = "Food" },
new Category {
Name = "Electronics" },
new Category {
Name = "Beverages" }
};
List<SubCategory>
subcategories = new List<SubCategory>
{
new SubCategory {
Name = "Vegetables", Category =
categories.Find(m => m.Name.Equals("Food")) },
new SubCategory {
Name = "Fruits", Category =
categories.Find(m => m.Name.Equals("Food")) },
new SubCategory {
Name = "Computer", Category =
categories.Find(m => m.Name.Equals("Electronics")) },
new SubCategory {
Name = "Television", Category =
categories.Find(m => m.Name.Equals("Electronics")) },
new SubCategory {
Name = "Cold Drinks", Category =
categories.Find(m => m.Name.Equals("Beverages")) },
new SubCategory {
Name = "Beer", Category =
categories.Find(m => m.Name.Equals("Beverages")) },
};
List<Product>
products = new List<Product>
{
new Product {
Name = "Wheat", Description = "Wheat",
SubCategory = subcategories.Find(m => m.Name.Equals("Vegetables")) },
new Product {
Name = "Apple", Description = "Apple",
SubCategory = subcategories.Find(m => m.Name.Equals("Fruits")) },
new Product {
Name = "Desktop", Description = "Desktop",
SubCategory = subcategories.Find(m => m.Name.Equals("Computer")) },
new Product {
Name = "LG", Description = "LG",
SubCategory = subcategories.Find(m => m.Name.Equals("Television")) },
new Product {
Name = "Sprite", Description = "Sprite",
SubCategory = subcategories.Find(m => m.Name.Equals("Cold
Drinks")) },
new Product {
Name = "Kingfisher", Description = "Kingfisher",
SubCategory = subcategories.Find(m => m.Name.Equals("Beer")) },
};
categories.ForEach(m => context.Category.Add(m));
subcategories.ForEach(m => context.SubCategory.Add(m));
products.ForEach(m => context.Product.Add(m));
context.SaveChanges();
base.Seed(context);
}
}
c) Create
new EFRepository class which implements IRepository interface for
doing CRUD by using entity framework:
/// <summary>
/// The
EF-dependent, generic repository for data access
/// </summary>
/// <typeparam
name="T">Type of entity for this Repository.</typeparam>
public class EFRepository<T>
: IRepository<T> where T : class
{
public
EFRepository(DbContext dbContext)
{
if
(dbContext == null)
throw new ArgumentNullException("dbContext");
DbContext
= dbContext;
DbSet =
DbContext.Set<T>();
}
protected DbContext
DbContext { get; set; }
protected DbSet<T>
DbSet { get; set; }
public virtual IQueryable<T>
GetAll()
{
return
DbSet;
}
public virtual T
GetById(int id)
{
return
DbSet.Find(id);
}
public virtual void
Add(T entity)
{
DbEntityEntry
dbEntityEntry = DbContext.Entry(entity);
if
(dbEntityEntry.State != EntityState.Detached)
{
dbEntityEntry.State = EntityState.Added;
}
else
{
DbSet.Add(entity);
}
}
public virtual void
Update(T entity)
{
DbEntityEntry
dbEntityEntry = DbContext.Entry(entity);
if
(dbEntityEntry.State == EntityState.Detached)
{
DbSet.Attach(entity);
}
dbEntityEntry.State = EntityState.Modified;
}
public virtual void
Delete(T entity)
{
DbEntityEntry
dbEntityEntry = DbContext.Entry(entity);
if
(dbEntityEntry.State != EntityState.Deleted)
{
dbEntityEntry.State = EntityState.Deleted;
}
else
{
DbSet.Attach(entity);
DbSet.Remove(entity);
}
}
public virtual void
Delete(int id)
{
var
entity = GetById(id);
if
(entity == null) return; //
not found; assume already deleted.
Delete(entity);
}
}
6) Add Helpers
folder in Sample.Data project and in that folder create a interface
IRepositoryProvider and two classes (RepositoryProvider and RepositoryFactories)
in order to create and find repository by using factory pattern:
a) IRepositoryProvider.cs
/// <summary>
///
Interface for a class that can provide repositories by type.
/// The
class may create the repositories dynamically if it is unable
/// to
find one in its cache of repositories.
/// </summary>
/// <remarks>
///
Repositories created by this provider tend to require a <see
cref="DbContext"/>
/// to
retrieve data.
/// </remarks>
public interface IRepositoryProvider
{
/// <summary>
/// Get
and set the <see cref="DbContext"/> with
which to initialize a repository
/// if
one must be created.
/// </summary>
DbContext
DbContext { get; set; }
/// <summary>
/// Get
an <see cref="IRepository{T}"/> for
entity type, T.
/// </summary>
/// <typeparam
name="T">
/// Root
entity type of the <see cref="IRepository{T}"/>.
/// </typeparam>
IRepository<T>
GetRepositoryForEntityType<T>() where T : class;
/// <summary>
/// Get
a repository of type T.
/// </summary>
/// <typeparam
name="T">
/// Type
of the repository, typically a custom repository interface.
/// </typeparam>
/// <param
name="factory">
/// An
optional repository creation function that takes a <see
cref="DbContext"/>
/// and
returns a repository of T. Used if the repository must be created.
/// </param>
/// <remarks>
///
Looks for the requested repository in its cache, returning if found.
/// If
not found, tries to make one with the factory, fallingback to
/// a
default factory if the factory parameter is null.
/// </remarks>
T
GetRepository<T>(Func<DbContext, object>
factory = null) where T : class;
/// <summary>
/// Set
the repository to return from this provider.
/// </summary>
/// <remarks>
/// Set
a repository if you don't want this provider to create one.
///
Useful in testing and when developing without a backend
///
implementation of the object returned by a repository of type T.
/// </remarks>
void
SetRepository<T>(T repository);
}
b) RepositoryProvider.cs
/// <summary>
///
Provides an <see cref="IRepository{T}"/> for
a client request.
/// </summary>
/// <remarks>
///
Caches repositories of a given type so that repositories are only created once
per provider.
///
Product application creates a new provider per client request.
/// </remarks>
public class RepositoryProvider : IRepositoryProvider
{
public
RepositoryProvider(RepositoryFactories
repositoryFactories)
{
_repositoryFactories = repositoryFactories;
Repositories = new Dictionary<Type, object>();
}
/// <summary>
/// Get
and set the <see cref="DbContext"/> with
which to initialize a repository
/// if
one must be created.
/// </summary>
public DbContext
DbContext { get; set; }
/// <summary>
/// Get
or create-and-cache the default <see
cref="IRepository{T}"/> for an entity of type T.
/// </summary>
/// <typeparam
name="T">
/// Root
entity type of the <see cref="IRepository{T}"/>.
/// </typeparam>
/// <remarks>
/// If
can't find repository in cache, use a factory to create one.
/// </remarks>
public IRepository<T>
GetRepositoryForEntityType<T>() where T : class
{
return
GetRepository<IRepository<T>>(
_repositoryFactories.GetRepositoryFactoryForEntityType<T>());
}
/// <summary>
/// Get
or create-and-cache a repository of type T.
/// </summary>
/// <typeparam
name="T">
/// Type
of the repository, typically a custom repository interface.
/// </typeparam>
/// <param
name="factory">
/// An
optional repository creation function that takes a DbContext argument
/// and
returns a repository of T. Used if the repository must be created and
///
caller wants to specify the specific factory to use rather than one
/// of
the injected <see cref="RepositoryFactories"/>.
/// </param>
/// <remarks>
///
Looks for the requested repository in its cache, returning if found.
/// If
not found, tries to make one using <see
cref="MakeRepository{T}"/>.
/// </remarks>
public virtual T
GetRepository<T>(Func<DbContext, object>
factory = null) where T : class
{
//
Look for T dictionary cache under typeof(T).
object
repoObj;
Repositories.TryGetValue(typeof(T), out
repoObj);
if
(repoObj != null)
{
return
(T)repoObj;
}
//
Not found or null; make one, add to dictionary cache, and return it.
return
MakeRepository<T>(factory, DbContext);
}
/// <summary>
/// Get
the dictionary of repository objects, keyed by repository type.
/// </summary>
/// <remarks>
///
Caller must know how to cast the repository object to a useful type.
/// <p>This
is an extension point. You can register fully made repositories here
/// and
they will be used instead of the ones this provider would otherwise create.</p>
/// </remarks>
protected Dictionary<Type, object>
Repositories { get; private set; }
/// <summary>Make
a repository of type T.</summary>
/// <typeparam
name="T">Type of repository to make.</typeparam>
/// <param
name="dbContext">
/// The <see
cref="DbContext"/> with which to initialize the
repository.
/// </param>
/// <param
name="factory">
///
Factory with <see cref="DbContext"/>
argument. Used to make the repository.
/// If
null, gets factory from <see cref="_repositoryFactories"/>.
/// </param>
/// <returns></returns>
protected virtual T
MakeRepository<T>(Func<DbContext, object>
factory, DbContext dbContext)
{
var f =
factory ?? _repositoryFactories.GetRepositoryFactory<T>();
if (f
== null)
{
throw new NotImplementedException("No
factory for repository type, " + typeof(T).FullName);
}
var repo
= (T)f(dbContext);
Repositories[typeof(T)] = repo;
return
repo;
}
/// <summary>
/// Set
the repository for type T that this provider should return.
/// </summary>
/// <remarks>
/// Plug
in a custom repository if you don't want this provider to create one.
///
Useful in testing and when developing without a backend
///
implementation of the object returned by a repository of type T.
/// </remarks>
public void
SetRepository<T>(T repository)
{
Repositories[typeof(T)] = repository;
}
/// <summary>
/// The <see
cref="RepositoryFactories"/> with which to create a new
repository.
/// </summary>
/// <remarks>
///
Should be initialized by constructor injection
/// </remarks>
private RepositoryFactories
_repositoryFactories;
}
c) RepositoryFactories.cs
/// <summary>
/// A
maker of Product app Repositories.
/// </summary>
/// <remarks>
/// An
instance of this class contains repository factory functions for different
types.
/// Each
factory function takes an EF <see cref="DbContext"/> and
returns
/// a
repository bound to that DbContext.
/// <para>
///
Designed to be a "Singleton", configured at web application start
with
/// all
of the factory functions needed to create any type of repository.
///
Should be thread-safe to use because it is configured at app start,
///
before any request for a factory, and should be immutable thereafter.
/// </para>
/// </remarks>
public class RepositoryFactories
{
/// <summary>
///
Return the runtime Product app repository factory functions,
/// each
one is a factory for a repository of a particular type.
/// </summary>
/// <remarks>
///
MODIFY THIS METHOD TO ADD CUSTOM FACTORY FUNCTIONS
/// </remarks>
private IDictionary<Type, Func<DbContext, object>>
GetProductFactories()
{
return new Dictionary<Type, Func<DbContext, object>>
{
};
}
/// <summary>
///
Constructor that initializes with runtime repository factories
/// </summary>
public
RepositoryFactories()
{
_repositoryFactories = GetProductFactories();
}
/// <summary>
///
Constructor that initializes with an arbitrary collection of factories
/// </summary>
/// <param
name="factories">
/// The
repository factory functions for this instance.
/// </param>
/// <remarks>
/// This
ctor is primarily useful for testing this class
/// </remarks>
public
RepositoryFactories(IDictionary<Type, Func<DbContext, object>>
factories)
{
_repositoryFactories = factories;
}
/// <summary>
/// Get
the repository factory function for the type.
/// </summary>
/// <typeparam
name="T">Type serving as the repository factory lookup
key.</typeparam>
/// <returns>The
repository function if found, else null.</returns>
/// <remarks>
/// The
type parameter, T, is typically the repository type
/// but
could be any type (e.g., an entity type)
/// </remarks>
public Func<DbContext, object>
GetRepositoryFactory<T>()
{
Func<DbContext, object>
factory;
_repositoryFactories.TryGetValue(typeof(T), out
factory);
return
factory;
}
/// <summary>
/// Get
the factory for <see cref="IRepository{T}"/>
where T is an entity type.
/// </summary>
/// <typeparam
name="T">The root type of the repository, typically an
entity type.</typeparam>
/// <returns>
/// A
factory that creates the <see cref="IRepository{T}"/>,
given an EF <see cref="DbContext"/>.
/// </returns>
/// <remarks>
/// Looks
first for a custom factory in <see
cref="_repositoryFactories"/>.
/// If
not, falls back to the <see
cref="DefaultEntityRepositoryFactory{T}"/>.
/// You
can substitute an alternative factory for the default one by adding
/// a
repository factory for type "T" to <see
cref="_repositoryFactories"/>.
/// </remarks>
public Func<DbContext, object>
GetRepositoryFactoryForEntityType<T>() where T : class
{
return
GetRepositoryFactory<T>() ?? DefaultEntityRepositoryFactory<T>();
}
/// <summary>
///
Default factory for a <see cref="IRepository{T}"/>
where T is an entity.
/// </summary>
/// <typeparam
name="T">Type of the repository's root entity</typeparam>
protected virtual Func<DbContext, object>
DefaultEntityRepositoryFactory<T>() where T : class
{
return
dbContext => new EFRepository<T>(dbContext);
}
/// <summary>
/// Get
the dictionary of repository factory functions.
/// </summary>
/// <remarks>
/// A
dictionary key is a System.Type, typically a repository type.
/// A
value is a repository factory function
/// that
takes a <see cref="DbContext"/>
argument and returns
/// a
repository object. Caller must know how to cast it.
/// </remarks>
private readonly IDictionary<Type, Func<DbContext, object>>
_repositoryFactories;
}
7)
Create ProductUow class that implements IProductUow in Sample.Data
project:
/// <summary>
/// The
Product "Unit of Work"
///
1) decouples the repos from the controllers
///
2) decouples the DbContext and EF from the controllers
///
3) manages the UoW
/// </summary>
/// <remarks>
/// This
class implements the "Unit of Work" pattern in which
/// the
"UoW" serves as a facade for querying and saving to the database.
///
Querying is delegated to "repositories".
/// Each
repository serves as a container dedicated to a particular
/// root
entity type such as a <see cref="Person"/>.
/// A
repository typically exposes "Get" methods for querying and
/// will
offer add, update, and delete methods if those features are supported.
/// The
repositories rely on their parent UoW to provide the interface to the
/// data
layer (which is the EF DbContext).
/// </remarks>
public class ProductUow : IProductUow, IDisposable
{
public
ProductUow(IRepositoryProvider repositoryProvider)
{
CreateDbContext();
repositoryProvider.DbContext = DbContext;
RepositoryProvider = repositoryProvider;
}
//
repositories
public IRepository<Product>
Products { get { return
GetStandardRepo<Product>(); } }
public IRepository<Category>
Categories { get { return
GetStandardRepo<Category>(); } }
public IRepository<SubCategory>
SubCategories { get { return
GetStandardRepo<SubCategory>(); } }
/// <summary>
/// Save
pending changes to the database
/// </summary>
public void
Commit()
{
DbContext.SaveChanges();
}
protected void
CreateDbContext()
{
DbContext
= new ProductDbContext();
}
protected IRepositoryProvider
RepositoryProvider { get; set; }
private IRepository<T>
GetStandardRepo<T>() where T : class
{
return
RepositoryProvider.GetRepositoryForEntityType<T>();
}
private T
GetRepo<T>() where T : class
{
return
RepositoryProvider.GetRepository<T>();
}
private ProductDbContext
DbContext { get; set; }
#region
IDisposable
public void
Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void
Dispose(bool disposing)
{
if
(disposing)
{
if
(DbContext != null)
{
DbContext.Dispose();
}
}
}
#endregion
}
8) Now in
order to use repository and unit of work in web application project (ManagingMultijQueryForm),
configure Ninject via package manager console, use of following command in
order to configure Ninject in an application:
a. Install-package
Ninject
b. Install-package
Ninject.MVC3
9)
Replace the Global.asax.cs MvcApplication class with the
following:
public class MvcApplication : NinjectHttpApplication
{
protected override IKernel
CreateKernel()
{
var
kernel = new StandardKernel();
kernel.Bind<RepositoryFactories>().To<RepositoryFactories>()
.InSingletonScope();
kernel.Bind<IRepositoryProvider>().To<RepositoryProvider>();
kernel.Bind<IProductUow>().To<ProductUow>();
return
kernel;
}
protected override void
OnApplicationStarted()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
}
}
10)
Last and final step, create a BaseController and inherit it in
all (ProductController, CategoryController and SubCategoryController)
controllers in order to use IProductUow:
a) BaseController:
public abstract class BaseController : Controller
{
protected IProductUow Uow
{ get; set; }
}
b) ProductController:
public class ProductController : BaseController
{
public
ProductController(IProductUow uow)
{
Uow = uow;
}
public ActionResult
Index()
{
return
View();
}
public ActionResult
List()
{
return
PartialView("_ProductList",
Uow.Products.GetAll().ToList());
}
public PartialViewResult
Add()
{
return
PartialView("_Product");
}
[HttpPost, ValidationActionFilter]
public PartialViewResult Add(Product
model)
{
Uow.Products.Add(model);
Uow.Commit();
return
Add();
}
public PartialViewResult
Edit(int id)
{
return
PartialView("_Product",
Uow.Products.GetById(id));
}
[HttpPost, ValidationActionFilter]
public PartialViewResult
Edit(Product model)
{
Uow.Products.Update(model);
Uow.Commit();
return
Add();
}
[HttpPost]
public JsonResult
Delete(int id)
{
var
product = Uow.Products.GetById(id);
Uow.Products.Delete(product);
Uow.Commit();
return
Json(new { success = true,
message = "Record deleted successfully!" }, "application/json", JsonRequestBehavior.AllowGet);
}
}
c) CategoryController:
public class CategoryController : BaseController
{
public
CategoryController(IProductUow uow)
{
Uow = uow;
}
public ActionResult
Index()
{
return
View();
}
public JsonResult Get(int id)
{
var
category = Uow.Categories.GetById(id);
return
Json(new { Id = category.CategoryID, Name = category.Name
}, "application/json", JsonRequestBehavior.AllowGet);
}
public PartialViewResult
List()
{
return
PartialView("_CategoryList",
Uow.Categories.GetAll().ToList());
}
[HttpPost]
public PartialViewResult
List(string s)
{
return
PartialView("_CategoryList",
Uow.Categories.GetAll().Where(m => m.Name.Contains(s)).ToList());
}
public PartialViewResult
Add()
{
return
PartialView("_Category");
}
[HttpPost, ValidationActionFilter]
public PartialViewResult Add(Category
model)
{
Uow.Categories.Add(model);
Uow.Commit();
return
Add();
}
[HttpPost]
public JsonResult
Delete(int id)
{
var
category = Uow.Categories.GetById(id);
Uow.Categories.Delete(category);
Uow.Commit();
return
Json(new { success = true,
message = "Record deleted successfully!" }, "application/json", JsonRequestBehavior.AllowGet);
}
}
d) SubCategoryController:
public class SubCategoryController : BaseController
{
public
SubCategoryController(IProductUow uow)
{
Uow = uow;
}
public ActionResult
Index()
{
return
View();
}
public JsonResult Get(int id)
{
var
subcategory = Uow.SubCategories.GetById(id);
return
Json(new { Id = subcategory.SubCategoryID, Name =
subcategory.Name }, "application/json", JsonRequestBehavior.AllowGet);
}
public PartialViewResult
List()
{
return
PartialView("_SubCategoryList",
Uow.SubCategories.GetAll().ToList());
}
[HttpPost]
public PartialViewResult
List(string s)
{
return
PartialView("_SubCategoryList",
Uow.SubCategories.GetAll().Where(m => m.Name.Contains(s) ||
m.Category.Name.Contains(s)).ToList());
}
public PartialViewResult
Add()
{
return
PartialView("_SubCategory");
}
[HttpPost, ValidationActionFilter]
public PartialViewResult Add(SubCategory
model)
{
Uow.SubCategories.Add(model);
Uow.Commit();
return
Add();
}
[HttpPost]
public JsonResult
Delete(int id)
{
var
subcategory = Uow.SubCategories.GetById(id);
Uow.SubCategories.Delete(subcategory);
Uow.Commit();
return
Json(new { success = true,
message = "Record deleted successfully!" }, "application/json", JsonRequestBehavior.AllowGet);
}
}
Before executing an application please do replace ManagingMultijQueryForm.Models with Sample.Model in all the views and remove
the reference of ManagingMultijQueryForm.Models
wherever it gives error.
Now you can run and test the application I hope it works
fine. You can download the source code from the link given below:
Download source code
I had taken a reference of Code Camper Spa application which
is developed and thought by great John
Papa.
Thanks for reading this article.
