Yes. Here’s my UnityDependencyResolver for instance.
using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.Practices.Unity;
namespace BuzzBox.Infrastructure.Web.Resolvers
{
public class UnityDependancyResolver : IDependencyResolver
{
private IUnityContainer _unityContainer;
public UnityDependancyResolver(IUnityContainer unityContainer)
{
_unityContainer = unityContainer;
}
public object GetService(Type serviceType)
{
return _unityContainer.IsRegistered(serviceType) ? _unityContainer.Resolve(serviceType) : null;
}
public IEnumerable<object> GetServices(Type serviceType)
{
return _unityContainer.IsRegistered(serviceType) ? _unityContainer.ResolveAll(serviceType) : new List<object>();
}
}
}
And in Global.asax…
public static void RegisterComponents()
{
IUnityContainer container = new UnityContainer();
container.RegisterType<BuzzBoxController>();
container.RegisterType<HomeController>();
container.RegisterType<IContextProvider, WebContextProvider>();
container.RegisterType<IAvatarRepository, AvatarRepository>();
container.RegisterType<ICategoryRepository, CategoryRepository>();
container.RegisterType<ICommentRepository, CommentRepository>();
container.RegisterType<IMemberRepository, MemberRepository>();
container.RegisterType<IPostRepository, PostRepository>();
container.RegisterType<IRatingRepository, RatingRepository>();
container.RegisterType<ISubscriptionRepository, SubscriptionRepository>();
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
}
That’s it. You don’t need to setup a custom controller factory or anything. Additionally, you can also use the following anywhere in your mvc app to resolve something.
var IAvatarRepository = DependencyResolver.Current.GetService<IAvatarRepository>();
This makes things nice because you can now setup a unit of work like this…
public class UnitOfWork : IUnitOfWork
{
private ObjectContext context;
private DbTransaction transaction;
public UnitOfWork()
{
this.context = Resolve<IContextProvider>().GetCurrentContext();
this.transaction = context.Connection.BeginTransaction();
}
public T Resolve<T>()
{
return DependencyResolver.Current.GetService<T>();
}
public void Dispose()
{
try
{
context.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
}
}
}
And as long you also inject your repositories with IContextProvider, you can do this…
using (IUnitOfWork worker = new UnitOfWork())
{
// safely use any combination of repositories you want
var postRepository = worker.Resolve<IPostRepository>();
var userRepository = worker.Resolve<IUserRepository>();
}
Here’s the context provider…
public interface IContextProvider
{
void SetCurrentContext(ObjectContext context);
ObjectContext GetCurrentContext();
}
public class WebContextProvider : IContextProvider
{
public void SetCurrentContext(ObjectContext context)
{
HttpContext.Current.Items["CurrentContext"] = context;
}
public ObjectContext GetCurrentContext()
{
return HttpContext.Current.Items["CurrentContext"] as ObjectContext;
}
}
Just set this up and tear it down in Global.asax using Application_BeginRequest and Application_EndRequest.