Autofac factory of unit of work in a singleton

Question

Plain and simple as the title suggests, is this a possible thing using Autofac dependency injection? I have been trying and searching everywhere.. I'm losing hope here.

My class has to be singleton - that can't change. I want it to take a factory of unit of works - for database transactions.

Please help me figure this one out, I'm deseperate.

Tried Func<> and registering my unit of work in every possible way (all sorts of lifetimes, externally owned or not) but failed because the DbContext within the unit of work is disposed and not created again after the first request

Edit:

Added code that will hopefully help understanding my problem:

public class SingletonDataService : IDataService
{
    private _uowFactory;

    public SingletonDataService(Func<IEFUnitOfWork> uowFactory)
    {
        _uowFactory = uowFactory
    }

    public List<Folder> GetAllFolders ()
    {
        using (uow = uowFactory())
        {
            return uow.FoldersRepository.GetAll();
        }
    }
}

public MyDbContext : DbContext
{
    public DbSet<Folder> Folders {get; set;}

    public DbSet<Letter> Letters {get; set;}

    public MyDbContext() : base("myContext...")
}

public EFUnitOfWork : IEFUnitOfWork, IDisposable
{
    public IRepository<Folder> FoldersRepository;
    public IRepository<Letter> LettersRepository;

    private DbContext _context;

    public EFUnitOfWork(IRepository<Folder> folders, IRepository<Letter> letters, DbContext context)
    {
        _folders = folders;
        _letters = letters;
        _context = context;
    }

    private bool disposed = false;

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

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                _context.Dispose();
            }

            disposed = true;
        }
    }
}

public Repository<T> : IRepository<T> where T: BaseEntity
{
    private DbContext _context;
    private DbSet<T> _set

    public Repository(DbContext context)
    {
        _context = context;
        _set = _context.Set<T>();
    }
}


public LettersController : ApiController
{
    private IDataService _dataService;

    public LettersController(IDataService dataService)
    {
        _dataService = dataService;
    }

    [HttpGet]
    public IHttpActionResult GetAllLetters()
    {
        return Ok(_dataService.GetAllLetters());
    }
}


// Must be singleton
builder.Register<SingletonDataService>().As(IDataService).SingleInstance();

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

builder.Register<EFUnitOfWork>().As(IEFUnitOfWork).InstancePerLifetimeScope();

builder.Register<DbContext>().As(AppDbContext).InstancePerLifetimeScope();

In the first request everything works fine, in the second third and so on I get this exception :

system.ObjectDisposedException: The ObjectContext instance has been disposed and can no longer be used for operations that require a connection.

I clearly see it happens because the context in my repository is now null, but I don't how to to change that with the DI.

What I want to achieve is so easy without DI :

How can I achieve the following with Autofac??

public class UowFactory
{
    public UowFactory()
    {

    }

    public IEFUnitOfWork Create()
    {
        var context = new AppDbContext()
        var uow = new EFUnitOfWork(new Repository<Folder>(context), new Repository<Letter>(context), context);
        return uow;
    }
}

Answer 1

Your problem is that you have a singleton (SingletonDataService) depend on a service that has a shorter lifetime (EFUnitOfWork). When the SingletonDataService instance is created by autofac, it gets an instance of EFUnitOfWork, but this instance will always stay the same (its actual lifetime will be longer than you expect) and thus gets disposed and used again, giving errors.

You have two possible solutions:

One is to create a UowFactory class like the one you defined at the bottom (but with dependencies on IRepository<Folder>, IRepository<Letter>, DbContext), register that as anything (for example singleton, but it won't matter) and make the SingletonDataService depend on it. This will likely not be a viable solution to you though, since it will also extend the lifetime of the IRepository<Folder>, IRepository<Letter>, DbContext instances and create problems there.

The proper solution is to remove the reason why you would want the SingletonDataService to be a singleton, probably some cache. And move it to a new service (CacheService?) on which the SingletonDataService depends and make that new service a singleton.

Answer 2

Issue

You are registering the critial components with InstancePerLifetimeScope()

When the autofac container is built it also creates a root ILifetimeScope which lives until IContainer.Dispose() is called. Now unless you create nested ILifetimeScope somewhere in the chain to the SingletonDataService, the ILifetimeScope which is used your components is the root ILifetimeScope and InstancePerLifetimeScope() effectly becomes equivalent to SingleInstance().

Solution

One of the possible solutions is to create an ILifetimeScope per IEFUnitOfWork and its children. Autofac facilitates this by providing the Owned<T> type. We can use it in conjunction with a Func<> factory (also see documentation):

public class SingletonDataService : IDataService
{
    private Func<Owned<IEFUnitOfWork>> _uowFactory;

    public SingletonDataService(Func<Owned<IEFUnitOfWork>> uowFactory)
    {
        _uowFactory = uowFactory
    }

    public List<Folder> GetAllFolders ()
    {
        using (var uow = _uowFactory())
        {
            return uow.Value.FoldersRepository.GetAll();
        }
    }
}

This should play nicely with the following registrations:

// Must be singleton
builder.Register<SingletonDataService>().As(IDataService).SingleInstance();

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

builder.Register<EFUnitOfWork>().As(IEFUnitOfWork).InstancePerLifetimeScope();

builder.Register<DbContext>().As(AppDbContext).InstancePerLifetimeScope();

However, note, that DbContext being bound with InstancePerLifetimeScope basically makes the manual disposal in EFUnitOfWork redundant.

Sidenote on proper Disposal

Since IDisposable types should support graceful multi-disposal , one should be able to simplify EFUnitOfWork.Dispose() to

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

Also note, that i left out the call GC.SuppressFinalize(this);. This call is only relevant in case the class implements a custom finalizer (~EFUnitOfWork method) - or a deriving class could do so, otherwise the object is not put on the finalizer queue anyway.