Developer Diaries

This post is a step-by-step guide to laying out a web app based on MVC4 and utilises autofac for IoC EF6 for data access, and implements the generic repository pattern.

I know there might be some other complete examples similar to what I am writing here, but I thought I can write this as a step-by-step, explaining every step of the way.

Background

Developer: I want to build A typical MVC4 web app that connects resiliently to a data store. This web app should be built using IoC and implements the Generic Repository Pattern.

Ingredients

Visual Studio 2012/2013 (any edition)
IIS Express (or IIS)
Sql Express (or Sql Server)
Internet connection :)

Recipe

Step 1 - MVC Web App

In this step, create a simple MVC 4 Web App by doing the following:

Open Visual studio
Create a new Web - MVC4 Web App project
Choose Empty Template

Step 2 - Install Autofac nuget package

To use Autofac for dependency Injection,

Open Package Manager (from Tools menu)
Search for Autofac.MVC4
Install it
Search for EntityFramework, and make sure you have included Prereleases.

Alternatively, you can run the following command from inside Package Manager Console

Install-Package Autofac.MVC4

Step 3 - Create DB Model

In this step, we will create a database model to represent data structure in the database.

Add a new class library project to the solution
Delete class1.cs from the project!
Create two new folders to the project namely, DatabaseModel and DataAccess. These folders will hold the database model and data access classes respectively.
right-click the first folder (DatabaseModel) and add new item
Choose ADO.NET Entity Data Model, and type a good name for it.
Choose "Generate from Database" in Model contents step, click Next
When prompted to choose EF version, choose EF 6.0
Select a couple of Tables from the database. (In this sample, I'm using AdventureWorks2012 database .. you can download it from this link)

Step 4 - Implement Generic Repository

Now that we created our database model, we'll create data access class that implements the generic repository pattern.

IDbContext: This interface will abstract all DBSets inside the context class generated in step3, and also adding a SaveChanges method which will be further used by Generic Repo to submit changes to the database

using System.Data.Entity;
using System.Data.Entity.Core.Objects;
using System.Data.Entity.Infrastructure;

namespace Blog.Samples.MVCEF6.Data.DataAcess
{
    public interface IDbContext
    {
        IDbSet<tentity> Set<tentity>() where TEntity : class;
        int SaveChanges();
    }

    public static class DbContextExtensions
    {
        public static ObjectContext GetObjectContext(this IDbContext dbContext)
        {
            return ((IObjectContextAdapter)dbContext).ObjectContext;
        }
    }
}

Change context t4 template to reference IDbConext. You should find this file under the database model, namely [Something].Context.tt ..
From

<#=Accessibility.ForType(container)#> partial class <#=code.Escape(container)#> : DbContext

<#=Accessibility.ForType(container)#> partial class <#=code.Escape(container)#> : DbContext, IDbContext

And add the following lines

#>
    public ObjectContext ObjectContext
    {
        get { return this.GetObjectContext(); }
    }

    public new IDbSet<tentity> Set<tentity>() where TEntity : class
    {
        return base.Set<tentity>();
    }

    public new int SaveChanges()
    {
        return base.SaveChanges();
    }
    <#

right after these lines

<#
    foreach (var entitySet in container.BaseEntitySets.OfType())
    {
#>
    <#=codeStringGenerator.DbSet(entitySet)#>
<#
    }

Also the Using directives

using System.Data.Entity.Core.Objects;
using Blog.Samples.MVCEF6.Data.DataAcess;

right after

using System;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;

Rebuild the project

IObjectContext: This interface abstracts the ObjectContext (which in turn encapsulates the interaction between the database and the CLR.

using System;
using System.Data.Entity.Core.Objects;

namespace Blog.Samples.MVCEF6.Data.DataAcess
{
    public interface IObjectContext : IDisposable
    {
        void SaveChanges();
        ObjectContextOptions ContextOptions { get; }
    }
}

IObjectSetFactory: factory pattern implementation over ObjectSets

using System;
using System.Data.Entity;
using System.Data.Entity.Core.Objects;

namespace Blog.Samples.MVCEF6.Data.DataAcess
{
    public interface IObjectSetFactory : IDisposable
    {
        IObjectSet<T> CreateObjectSet<T>() where T : class;
        void ChangeObjectState(object entity, EntityState state);
    }
}

ContextAdaptor: an Implementation of IObjectSetFactory and IObjectContext

using System;
using System.Data.Entity;
using System.Data.Entity.Core.Objects;

namespace Blog.Samples.MVCEF6.Data.DataAcess
{
    public class ContextAdaptor : IObjectSetFactory, IObjectContext
    {
        private readonly ObjectContext _context;

        public ContextAdaptor(IDbContext context)
        {
            _context = context.GetObjectContext();
        }

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

        public ObjectContextOptions ContextOptions
        {
            get { return _context.ContextOptions; }
        }

        public IObjectSet<T> CreateObjectSet<T>() where T : class
        {
            return _context.CreateObjectSet<T>();
        }

        public void ChangeObjectState(object entity, EntityState state)
        {
            _context.ObjectStateManager.ChangeObjectState(entity, state);
        }

        private bool _disposed;
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing && _context != null)
                {
                    _context.Dispose();
                }
            }
            _disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }
}

IUnitOfWork and its implementation: this will control when/how to commit CLR changes to database

using System;

namespace Blog.Samples.MVCEF6.Data.DataAcess
{
    public interface IUnitOfWork : IDisposable
    {
        void Commit();
        bool LazyLoadingEnabled { set; get; }
    }
}

and its implementation

using System;

namespace Blog.Samples.MVCEF6.Data.DataAcess
{
    public class UnitOfWork : IUnitOfWork
    {
        private readonly IObjectContext _objectContext;

        public UnitOfWork(IObjectContext objectContext)
        {
            _objectContext = objectContext;
        }

        public void Commit()
        {
            _objectContext.SaveChanges();
        }

        public bool LazyLoadingEnabled
        {
            set { _objectContext.ContextOptions.LazyLoadingEnabled = value; }
            get { return _objectContext.ContextOptions.LazyLoadingEnabled; }
        }

        private bool _disposed;
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing && _objectContext != null)
                {
                    _objectContext.Dispose();
                }
            }
            _disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }
}

IRepository: This interface abstracts all Repository-related operations, such as Get, Delete, Count, etc...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace Blog.Samples.MVCEF6.Data.DataAcess
{
    public interface IRepository<TEntity> : IQueryable
        where TEntity : class
    {
        int CountAll(params Expression<Func<TEntity, object>>[] includeProperties);
        int Count(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties);
        IEnumerable<TEntity> GetAll(params Expression<Func<TEntity, object>>[] includeProperties);
        IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties);
        TEntity Single(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties);
        TEntity SingleOrDefault(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties);
        TEntity First(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties);
        TEntity FirstOrDefault(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties);
        void Delete(TEntity entity);
        void Insert(TEntity entity);
        void Update(TEntity entity);
        void SaveChanges();
    }
}

Repository'T: Implementation of IRepository interface

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Core.Objects;
using System.Linq;
using System.Linq.Expressions;

namespace Blog.Samples.MVCEF6.Data.DataAcess
{
    public class Repository<TEntity> : IRepository<TEntity>, IQueryable
        where TEntity : class
    {
        private readonly IObjectSet<TEntity> _objectSet;
        private readonly IObjectSetFactory _objectSetFactory;
        private readonly IUnitOfWork _unitOfWork;

        public Repository(IObjectSetFactory objectSetFactory, IUnitOfWork unitOfWork)
        {
            _objectSet = objectSetFactory.CreateObjectSet<TEntity>();
            _objectSetFactory = objectSetFactory;
            _unitOfWork = unitOfWork;
        }

        public virtual IQueryable<TEntity> AsQueryable()
        {
            return _objectSet;
        }

        public virtual int CountAll(params Expression<Func<TEntity, object>>[] includeProperties)
        {
            IQueryable<TEntity> query = AsQueryable();
            query = PerformInclusions(includeProperties, query);
            return query.Count();
        }

        public virtual int Count(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties)
        {
            IQueryable<TEntity> query = AsQueryable();
            query = PerformInclusions(includeProperties, query);
            return query.Count(where);
        }

        public virtual IEnumerable<TEntity> GetAll(params Expression<Func<TEntity, object>>[] includeProperties)
        {
            IQueryable<TEntity> query = AsQueryable();
            query = PerformInclusions(includeProperties, query);
            return query.ToList();
        }

        public virtual IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> where,
                                   params Expression<Func<TEntity, object>>[] includeProperties)
        {
            IQueryable<TEntity> query = AsQueryable();
            query = PerformInclusions(includeProperties, query);
            return query.Where(where);
        }

        public virtual TEntity Single(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties)
        {
            IQueryable<TEntity> query = AsQueryable();
            query = PerformInclusions(includeProperties, query);
            return query.Single(where);
        }

        public virtual TEntity First(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties)
        {
            IQueryable<TEntity> query = AsQueryable();
            query = PerformInclusions(includeProperties, query);
            return query.First(where);
        }

        public virtual TEntity SingleOrDefault(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties)
        {
            IQueryable<TEntity> query = AsQueryable();
            query = PerformInclusions(includeProperties, query);
            return query.SingleOrDefault(where);
        }

        public virtual void Delete(TEntity entity)
        {
            _objectSet.DeleteObject(entity);
        }

        public virtual void Insert(TEntity entity)
        {
            _objectSet.AddObject(entity);
        }

        public virtual void Update(TEntity entity)
        {
            _objectSet.Attach(entity);
            _objectSetFactory.ChangeObjectState(entity, EntityState.Modified);
        }

        private static IQueryable<TEntity> PerformInclusions(IEnumerable<Expression<Func<TEntity, object>>> includeProperties,
                                                       IQueryable<TEntity> query)
        {
            return includeProperties.Aggregate(query, (current, includeProperty) => current.Include(includeProperty));
        }


        public void SaveChanges()
        {
            _unitOfWork.Commit();
        }

        public TEntity FirstOrDefault(Expression<Func<TEntity, bool>> where, params Expression<Func<TEntity, object>>[] includeProperties)
        {
            var query = AsQueryable();
            query = PerformInclusions(includeProperties, query);
            return query.FirstOrDefault(where);
        }

        public IEnumerator GetEnumerator()
        {
            return _objectSet.GetEnumerator();
        }

        public Expression Expression
        {
            get { return _objectSet.Expression; }
        }
        public Type ElementType
        {
            get { return _objectSet.ElementType; }
        }
        public IQueryProvider Provider
        {
            get { return _objectSet.Provider; }
        }
    }
}

Your Data project should look similar to this:

Step 5 - Implement Domain Assembly

So, we got the database model, and data access classes. Now, we are going to implement some business (domain) services that should consume database and perform some logic on it. This assembly will serve the WebApp (or whatever app) that we created in Step1

Add a new class library project to the solution
step 5 first pic goes here
Name it something awesome
Delete class1.cs :)
Add reference to the Data project
Beef up the assembly by adding a sample service that uses data access classes to retrieve a list of models

right-click the domain project
add a new folder with the name of 'Services' (arbitrarily)

Add a new interface under this folder, name it IProductsServices:

using System.Collections.Generic;
using Blog.Samples.MVCEF6.Data.DatabaseModel;


namespace Blog.Samples.MVCEF6.Domain.Services
{
    public interface IProductsServices
    {
        IEnumerable<product> ListProductsByVendor(int businessEntityID);
        IEnumerable<vendor> ListVendors();
    }
}

Implement the interface by consuming the Repository'T

using System.Collections.Generic;
using System.Linq;
using Blog.Samples.MVCEF6.Data.DataAcess;
using Blog.Samples.MVCEF6.Data.DatabaseModel;

namespace Blog.Samples.MVCEF6.Domain.Services
{
    public class ProductsServices : IProductsServices
    {
        private readonly IRepository<Product> _productsRepository;
        private readonly IRepository<Vendor> _vendorsRepository;
        private readonly IRepository<ProductVendor> _productsVendorsRepository;

        public ProductsServices(IRepository<Product> productsRepository,
            IRepository<Vendor> vendorsRepository,
            IRepository<ProductVendor> productsVendorsRepository)
        {
            _productsRepository = productsRepository;
            _vendorsRepository = vendorsRepository;
            _productsVendorsRepository = productsVendorsRepository;
        }

        public IEnumerable<Product> ListProductsByVendor(int businessEntityID)
        {
            return _productsRepository.Find(a => a.ProductVendors.Any(pv => pv.BusinessEntityID == businessEntityID));
        }

        public IEnumerable<Vendor> ListVendors()
        {
            return _vendorsRepository.GetAll();
        }
    }
}

Step 6 - Wire up using Autofac

We've got the database model and the Data access classes and domain assembly, the next step is to wire all this up with the web application using Autofac.

In the web app project, Add reference to the domain project that we created in Step 5,
Add DependencyConfig class: This class contains any IoC-related code, We're going to call its main function from Global.asax.cs

right-click the App_start folder in the web project, and add a new class, name it "DependencyConfig"

Add the following code to the class:

using Autofac;
using Autofac.Integration.Mvc;
using Blog.Samples.MVCEF6.Data.DataAcess;
using Blog.Samples.MVCEF6.Data.DatabaseModel;
using System.Web.Mvc;

namespace Blog.Samples.MVCEF6.Web.App_Start
{
    public class DependencyConfig
    {
        public static void Configure(ContainerBuilder builder)
        {
            builder.RegisterControllers(typeof(MvcApplication).Assembly)
                   .PropertiesAutowired();

            builder.RegisterAssemblyTypes(typeof(ContextAdaptor).Assembly)
                .AsImplementedInterfaces()
                .InstancePerHttpRequest();

            builder.RegisterType<AdventureWorks2012Entities>()
                .As<IDbContext>()
                .InstancePerHttpRequest();

            builder.RegisterType<ContextAdaptor>()
                .As<IObjectSetFactory, IObjectContext>()
                .InstancePerHttpRequest();

            builder.RegisterType<UnitOfWork>()
                .As<IUnitOfWork>()
                .InstancePerHttpRequest();

            builder.RegisterGeneric(typeof(Repository<>))
                .As(typeof(IRepository<>))
                .InstancePerHttpRequest();

            var container = builder.Build();
            var dependencyResolver = new AutofacDependencyResolver(container);
            DependencyResolver.SetResolver(dependencyResolver);
        }
    }
}

Call DepedencyConfig.Configure from global.asax.cs

add the following line inside Aplication_start function, right after RegisterAllAreas line
```
DependencyConfig.Configure(new ContainerBuilder());
```

Step 7 - Add some Controllers/Views to test it out

Let's now add some MVC stuff in the web project:

right-click Models folder, add a new class to represent the HomeViewModel:

using Blog.Samples.MVCEF6.Data.DatabaseModel;
using System.Collections.Generic;

namespace Blog.Samples.MVCEF6.Web.Models
{
    public class HomeViewModel
    {
        public IEnumerable<Vendor> Vendors { get; set; }
        public int SelectedBusinessEntityID { get; set; }
    }
}

right-click Controllers folder, and a new HomeController, Use the following code to beef it up.

using System.Web.Mvc;
using Blog.Samples.MVCEF6.Domain.Services;
using Blog.Samples.MVCEF6.Web.Models;

namespace Blog.Samples.MVCEF6.Web.Controllers
{
    public class HomeController : Controller
    {
        private readonly IProductsServices _productsServices;

        public HomeController(IProductsServices productsServices)
        {
            _productsServices = productsServices;
        }

        public ActionResult Index()
        {
            return View(new HomeViewModel()
                {
                    Vendors = _productsServices.ListVendors()
                });
        }

    }
}

right-click Views folder, and a new folder, name it "Home" ..right-click Home folder under Views, add an Index view. You can reference _Layout.cshtml as the master page. Use the following code to beef it up.

@model Blog.Samples.MVCEF6.Web.Models.HomeViewModel
@{
    ViewBag.Title = "Index";
    Layout = "~/Views/Shared/_Layout.cshtml";
}

<h2>Index</h2>

@Html.DropDownListFor(m => m.SelectedBusinessEntityID, Model.Vendors.Select(v => new SelectListItem
    {
        Text = v.Name,
        Value = v.BusinessEntityID.ToString()
    }))

I won't be consuming the GetProductByVendor in this sample, I'm leaving this for you as an exercise.

You can find the complete code here

Developer Diaries

Monday, September 19, 2016

Are you addressing a pain or you just polka polka?!

Saturday, October 5, 2013

Step-by-step Guide - MVC 4 + Entity Framework 6 + Autofac + Generic Repository Pattern

Step 1 - MVC Web App

Step 2 - Install Autofac nuget package

Step 3 - Create DB Model

Step 4 - Implement Generic Repository

Step 5 - Implement Domain Assembly

Step 6 - Wire up using Autofac

Step 7 - Add some Controllers/Views to test it out

Thursday, September 26, 2013

Load testing your cloud app - Tools comparison

Soasta – CloudTest

Pros

Cons

Pricing

Blitz

Pros

Cons

Pricing

BlazeMeter

Pros

Cons

Pricing

LoadStorm

Pros

Cons

Pricing

Microsoft Cloud-based Load test tool

Pros

Cons

Pricing

SyntaxHighlighter

Feedjit