Ninject Scope issue with Tasks/Threads

Question

I have an MVC3 project that uses Ninject, Entity Framework and the Unit of Work pattern with a Service layer.

My AsyncService class has a function that starts a background task that, as an example, adds users to the User repository. My current problem is that the task only runs correctly for a few seconds before I get an error that the DbContext has been disposed. My database context, which is injected with Ninject's InRequestScope() seems to be getting disposed, as InRequestScope() ties it to HttpContext.

I've read about InThreadScope(), however I'm not sure how to implement it properly in my MVC project.

My Question is: What is the correct way to use Ninject in my Task?

public class AsyncService
{
    private CancellationTokenSource cancellationTokenSource;
    private IUnitOfWork _uow;
    public AsyncService(IUnitOfWork uow)
    {
        _uow = uow;
    }
    public void AsyncStartActivity(Activity activity)
    {
    ...snip...
        this.cancellationTokenSource = new CancellationTokenSource();
        var cancellationToken = this.cancellationTokenSource.Token;
        var task = Task.Factory.StartNew(() =>
            {
                foreach (var user in activity.UserList)
                {
                    this._uow.UserRepository.Add(new User() {UserID = user});
                }
                this._uow.Save();
            }, cancellationToken);
     ...snip...
    }
}

Answer 1

InRequestScope'd objects are Disposed at the end of a request so it can't be used in this case. InThreadScope also doesn't fit as that would reuse the UoW for several tasks.

What you can do though is declare your AsyncService as the Scoping Object for all the objects within using the NamedScope extension.

See http://www.planetgeek.ch/2010/12/08/how-to-use-the-additional-ninject-scopes-of-namedscope/

Answer 2

This is a messy solution that I've used in the past using the ChildKernel plugin (I think Named scope would much cleaner). Basically I create a child kernel, and scope everything pertaining to the UoW as singleton in the child kernel. I then create a new child kernel for each Task, handle the UoW, and commit or rollback.

IAsyncTask is an interface with 1 method, Execute()

private Task void ExecuteTask<T>() where T:IAsyncTask
{

        var task = Task.Factory.StartNew(() =>
                                             {
            var taskKernel = _kernel.Get<ChildKernel>();
            var uow = taskKernel.Get<IUnitOfWork>();
            var asyncTask = taskKernel.Get<T>();

            try
            {
                uow.Begin();
                asyncTask.Execute();
                uow.Commit();
            }
            catch (Exception ex)
            {
                uow.Rollback();
                //log it, whatever else you want to do
            }
            finally
            {
                uow.Dispose();
                taskKernel.Dispose();
            }
      });
      return task;
}