我是否以正确的方式使用Unity和UnitOfWork？

Question

Am I correct doing this? Can there be problems with memory usage or performance?

UPD:Bug with disposed context is fixed.

I'm using Unity with the Unit of Work pattern. When I run my application for the first time, everything works as expected, but once I refresh the page, the app crashes with the following exception:

The operation cannot be completed because the DbContext has been disposed.

My DI configuration looks like this:

private static IUnityContainer BuildUnityContainer()
{
    var container = new UnityContainer();

    container.RegisterType<DataContext>();

    container.RegisterType<IUnitOfWorkFactory, UnitOfWorkFactory>();

    container.RegisterType<IUnitOfWork, UnitOfWork>();

    container.RegisterType<IProductRepository, ProductRepository>();

    return container;
}

My UnitOfWork and UnitOfWorkFactory look like this:

public class UnitOfWork : IUnitOfWork
{
    private readonly IUnityContainer _container;
    private bool _disposed;

    public UnitOfWork(IUnityContainer container)
    {
        _container = container;
        Context = _container.Resolve<DataContext>();
    }

    internal DataContext Context { get; set; }

    public TRepository GetRepository<TRepository>() 
        where TRepository : class
    {
        return _container.Resolve<TRepository>();
    }

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

    public void Dispose()
    {
        if (!_disposed)
        {
            _disposed = true;
            Context.Dispose();
        }
    }
}

public class UnitOfWorkFactory : IUnitOfWorkFactory
{
    private readonly IUnityContainer _container;

    public UnitOfWorkFactory(IUnityContainer container)
    {
        _container = container;
    }

    public IUnitOfWork CreateUnitOfWork()
    {
        return _container.Resolve<UnitOfWork>();
    }
}

The UnitOfWork contains a GetRepository method that allows returning any repository. Here is an example of such a repository:

public class ProductRepository : BaseRepository<Product>,
    IProductRepository
{
    public ProductRepository(UnitOfWork unitOfWork)
        :base(unitOfWork)
    {
    }

    public Product Create(Product entity)
    {
        return DataBase.Add(entity);
    }

    public Product Remove(Product entity)
    {
        return DataBase.Remove(entity);
    }

    public Product Get(Int32 entityId)
    {
        return DataBase.FirstOrDefault(x => x.Id == entityId);
    }
}

public class BaseRepository<TEntity> 
    where TEntity : class
{
    internal BaseRepository(UnitOfWork unitOfWork)
    {
        UnitOfWork = unitOfWork;

    }

    internal UnitOfWork UnitOfWork { get; private set; }

    internal virtual IDbSet<TEntity> DataBase
    {
        get { return UnitOfWork.Context.Set<TEntity>(); }
    }
}

My MVC controllers depend on IUnitOfWorkFactory . Here is the AccountController for example:

public class AccountController : Controller
{
    private readonly IUnitOfWorkFactory _unitOfWorkFactory;

    public AccountController(IUnitOfWorkFactory unitOfWorkFactory)
    {
        _unitOfWorkFactory = unitOfWorkFactory;
    }

    [AllowAnonymous]
    public ActionResult Login(string returnUrl)
    {
        ViewBag.ReturnUrl = returnUrl;

        using (var uow = _unitOfWorkFactory.CreateUnitOfWork())
        {
            var rep = uow.GetRepository<IProductRepository>();

            var prod = rep.GetById(1);
        }

        return View();
    }
}

Answer 1

You are telling Unity to create UnitOfWork once (singleton):

    container.RegisterType<IUnitOfWork, UnitOfWork>(
    new ContainerControlledLifetimeManager());

I dont think you want that. Remove the ContainerControlledLifetimeManager()....

Answer 2

I think this is because of the LifetimeManager you are using. (A LifetimeManager holds onto an instance given to it.) Your instance is disposed, but becouse of the ContainerControlledLifetimeManager, it doesn't create a new one. In this article you can read how you can resolve this issue.

Basically it is a good idea to use Unity.MVC3 package, and define a HierarchicalLifetimeManager for your IDisposable dependencies.