Below is the series outline; again, this is Part 4.
- Part 1: Setup
- This post involves downloading and creating the SQL Server database, setting up the Visual Studio solution and project structure, and generating the out-of-the-box Entity Framework (EF/EF4) data model from the newly created database.
- Part 2: Creating the Repositories and Unit of Work (UoW)
- This is the meat of the series. This post includes downloading some T4 templates, settings a few parameters, and generating the Repositories and Unit of Work (UoW) using the T4 templates and EF4 data model.
- Part 3: Review Some of The Generated Code
- This post will review a few of the generated class/interfaces that the T4 code generation created.
- Part 4: Using EF, Repository & UoW in an ASP.NET MVC 3 Project
- This post includes wiring up the EF4 data model, repositories, and UoW to StructureMap dependency injection container and use of these products in an ASP.NET MVC 3 Web application project.
- Core
- Infrastructure
- Web
Next, create an ASP.NET MVC 3 Web Application and name is ‘Chinook.Web’ and click ‘OK.’ 
On the next screen, select ‘Internet Application,’ the ‘Razor’ View engine, and click ‘OK’ 
Right-click the new ‘Chinook.Web’ Application Project and select ‘Set As Startup Project.’ The solution structure should now look similar to the following: 
Add the following References to the ‘Chinook.Web’ Project and then build the solution. 
In the description of this post, it states that we are going to use StructureMpa as our DI container. We are going to get StructureMap via NuGet. Assuming you have NuGet installed, select the Chinook.Web project, open the ‘Package Manager Console,’ and type the following command: PM> Install-Package StructureMap
Go ahead and build the solution. Next, add the the new StructureMap reference to both the Chinook.Data.EF and Chinook.Infrastructure projects and rebuild the solution. Again, this series assumes that you have all the necessary tools (NuGet, POCO templates, etc…) installed with Visual Studio and that you are somewhat familiar with StructureMap. Now, remember the two files (EFRepositoryRegistry.cs.txt and ServicesRegistry.cs.txt) that the T4 templates generated for us in the previous post? We are going to use those files to create our StructureMap registries. The best way to do this is to create two new cs files in the respective projects, copy the code from the generated file, and paste it into these new code files. I understand this is not idea (copy, paste, etc…); however, I didn’t want to limit our solution to StructureMap only, so we’ll just have to deal with the awkwardness for now. So, create the following files and replace all the code in the new code file with the code in the associated generated file. - EFRepositoryRegistry.cs – in the Chinook.Data.EF project
- EFRepositoryRegistry.cs.txt – generated file
- ServicesRegistry.cs – in the Services directory within the Chinook.Implementation project
- ServicesRegistry.cs.txt – generated file
- StructureMapContainerSetup.cs – make this class static
- StructureMapDependencyResolver.cs
StructureMapDependencyResolver
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using StructureMap;
namespace Chinook.Web.Bootstrap
{
public class StructureMapDependencyResolver : IDependencyResolver
{
private readonly IContainer _container;
public StructureMapDependencyResolver(IContainer container)
{
_container = container;
}
#region Implementation of IDependencyResolver
/// <summary>
/// Resolves singly registered services that support arbitrary object creation.
/// </summary>
/// <returns>
/// The requested service or object.
/// </returns>
/// <param name="serviceType">The type of the requested service or object.</param>
public object GetService(Type serviceType)
{
var instance = _container.TryGetInstance(serviceType);
if ((instance == null) && !serviceType.IsAbstract)
{
_container.Configure(c => c.AddType(serviceType, serviceType));
instance = _container.TryGetInstance(serviceType);
}
return instance;
}
/// <summary>
/// Resolves multiply registered services.
/// </summary>
/// <returns>
/// The requested services.
/// </returns>
/// <param name="serviceType">The type of the requested services.</param>
public IEnumerable<object> GetServices(Type serviceType)
{
return _container.GetAllInstances(serviceType).Cast<object>();
}
#endregion
}
}
StructureMapContainerSetup
using System.Web.Mvc;
using Chinook.Data.EF;
using Chinook.Infrastructure.Services;
using StructureMap;
namespace Chinook.Web.Bootstrap
{
public static class StructureMapContainerSetup
{
public static void Setup()
{
IContainer container = new Container(
x =>
{
x.AddRegistry(new EFRepositoryRegistry());
x.AddRegistry(new ServicesRegistry());
}
);
DependencyResolver.SetResolver(new StructureMapDependencyResolver(container));
}
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
StructureMapContainerSetup.Setup();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
}
- Create a ViewModel - AlbumGridItemViewModel.
- Create a IViewModelBuilder/ViewModelBuilder – IAlbumGridItemViewModelBuilder/AlbumGridItemViewModelBuilder.
- Create a new Controller - AlbumController.
- Use constructor injection to inject the ViewModelBuilder into the Controller - IAlbumGridItemViewModelBuilder into the AlbumController.
- Create a View to represent a list of ViewModel items – Index – this is only a list of items; however, the process remains the same for all types of views.
- Register the IViewModelBuilder/ViewModelBuilder with StructureMap – using a similar pattern as the other DI registrations – a StructureMap Registry.
Thanks for reading…
) read-only interfaces to the persistence layer.
