ObjectDisposedException due to scoping of the UnitOfWork.

I'm having problems returning Lightspeed objects in methods. More specifically, when trying to access properties on the returned object, I'm presented with ObjectDisposedExceptions. For example, my underlying class is:

    public sealed class BLLContext : IDisposable
{
    private static readonly LightSpeedContext<DatabaseUnitOfWork> context = new LightSpeedContext<DatabaseUnitOfWork>("default")
    {
        QuoteIdentifiers = true
    };

    private DatabaseUnitOfWork unitOfWork = context.CreateUnitOfWork();

    public C CreateController<C>() where C : BLLController, new()
    {
        C controller = new C();
        controller.UnitOfWork = unitOfWork;

        return controller;
    }

    public void Dispose()
    {
        unitOfWork.Dispose();
        unitOfWork = null;
    }
}

And I would use as follows:

            using (BLLContext bll = new BLLContext())
        {
            BLL.UserController controller = bll.CreateController<BLL.UserController>();
            return controller.LoadAll(); // Return type IQueryable<DAL.User>
        }

The trouble is, the BLLContext object (and therefor the underlying UnitofWork) is disposed immediately after the return statement. When trying to access any of the returned User object's properties I'm presented with an ObjectDisposedException exception.

I can get around this by adding a call to .ToList() - return controller.LoadAll().ToList(). This effectively creates a copy of the original User collection - thus removing the scoping issue - but it feels like a hacky way to work around the problem.

What should I be doing here? Am I using Lightspeed in a way it was not designed to be used?

This is fine, what you need to do is explicitely call UnitOfWork.Detach for each User object you are loading to detach them from the UnitOfWork.

The exception comes from trying to lazily load association data which requires access to a UnitOfWork. Because the instances have not been detached they try and access the UnitOfWork they were associated with (the one they were loaded in) but since it has been disposed the exception is triggered.

Jeremy

Hi Jeremy.

Thanks for the prompt response!

I wasn't familiar with the Detach method, so that really helps (and feels much cleaner that the .ToList() approach).

I fully understand the issue with lazy loading, and use eager loading where necessary.