Ninject，MVC5，EF6，存储库+ UoW

Question

I'm having two problems, the first is scaling and became visible while load testing.

Under load, things quickly (10 concurrent or less) fail with the error:

There is already an open DataReader associated with this Command which must be closed first.

Or

ExecuteReader requires an open and available Connection. The connection's current state is open.

The stack trace references a repository every time, example:

Line 23:         public AboutViewDto GetAboutView()
Line 24:         {
Line 25:             var featured = UnitOfWork.FaqRepository
Line 26:                 .GetFeatured()

Original NinjectDependencyResolver:

    public class NinjectDependencyResolver 
        : IDependencyResolver, System.Web.Mvc.IDependencyResolver
    {
        private readonly IKernel _kernel;

        public NinjectDependencyResolver() : this(new StandardKernel())
        {

        }

        public NinjectDependencyResolver(IKernel kernel)
        {
            _kernel = kernel;
            AddBindings(_kernel);
        }

        public IDependencyScope BeginScope()
        {
            return this;
        }

        public object GetService(Type serviceType)
        {
            return _kernel.TryGet(serviceType);
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return _kernel.GetAll(serviceType);
        }

        public void Dispose()
        {
            // nothing?? 
        }

        private static void AddBindings(IBindingRoot kernel)
        {

            kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();

            kernel.Bind<IDataContext>().To<PublicCommentDbContext>().InSingletonScope();
            kernel.Bind<IUnitOfWork>().To<UnitOfWork>().InSingletonScope();

            kernel.Bind(typeof(IRepository<>)).To(typeof(Repository<>)).InSingletonScope();
            kernel.Bind<IFaqRepository>().To<FaqRepository>().InSingletonScope();
            kernel.Bind<IListValueRepository>().To<ListValueRepository>().InSingletonScope();
            kernel.Bind<INoticeRepository>().To<NoticeRepository>().InSingletonScope();
            kernel.Bind<IOrganizationRepository>().To<OrganizationRepository>().InSingletonScope();
            kernel.Bind<ITagRepository>().To<TagRepository>().InSingletonScope();

            kernel.Bind<IAdminService>().To<AdminService>();
            kernel.Bind<IAutoMapperService>().To<AutoMapperService>();
            kernel.Bind<IHomeService>().To<HomeService>();
            kernel.Bind<IInfoService>().To<InfoService>();
            kernel.Bind<IMailService>().To<MailService>();
            kernel.Bind<INoticeService>().To<NoticeService>();
            kernel.Bind<IOrganizationService>().To<OrganizationService>();
            kernel.Bind<ISearchService>().To<SearchService>();

            kernel.Bind<IValidator<QuestionDto>>().To<QuestionDtoValidator>();
            kernel.Bind<IValidator<NoticeCommentDto>>().To<CommentDtoValidator>();
            kernel.Bind<IValidator<NoticeContactDto>>().To<NoticeContactDtoValidator>();
            kernel.Bind<IValidator<NoticeDto>>().To<NoticeDtoValidator>();
            kernel.Bind<IValidator<OrganizationDto>>().To<OrganizationDtoValidator>();

        }
    }
}

I had a hunch that InSingletonScope() was causing the problem so I changed it to:

kernel.Bind<IDataContext>().To<PublicCommentDbContext>().InRequestScope();

And changed all of the other SingletonScopes to RequestScope.

After making that change, the site handles 400+ concurrent users without any failures, however...

Now no commits work against the database. I can trace the calls through the controller, to the service, to the repository, and to the DBContext commit, but the inserts or updates are not happening.

I'll post snippets of each item here in hopes someone can spot the dumb error we've made or suggest improvements.

Snippets follow:

Activity, update a Notice, everything involved:

1) Ninject:

kernel.Bind<IDataContext>().To<PublicCommentDbContext>().InRequestScope();
kernel.Bind<IUnitOfWork>().To<UnitOfWork>().InRequestScope();
kernel.Bind(typeof(IRepository<>)).To(typeof(Repository<>)).InRequestScope();
kernel.Bind<INoticeService>().To<NoticeService>();
 .. etc...

2) Controller:

public sealed class NoticeController : BaseController
{
    public NoticeController(IAutoMapperService autoMapperService, INoticeService noticeService)
    {
        AutoMapperService = autoMapperService;
        NoticeService = noticeService;
    }
...

3) NoticeService

public class NoticeService : BaseService, INoticeService
{
    public NoticeService(
        IUnitOfWork unitOfWork, 
        IAutoMapperService autoMapperService,
        IValidator<NoticeDto> noticeDtoValidator)
        : base(unitOfWork)
    {
        AutoMapperService = autoMapperService;
        NoticeDtoValidator = noticeDtoValidator;
    }

4) Unit of Work

public class UnitOfWork : IUnitOfWork
{
    private IDataContext _dataContext;
    private bool _disposed;
    private ObjectContext _objectContext;
    private DbTransaction _transaction;

    public UnitOfWork(
        IDataContext dataContext,
        INoticeRepository noticeRepository)
    {
        _dataContext = dataContext;
        NoticeRepository = noticeRepository;
    }

5) Notice Repository

public class NoticeRepository : Repository<Notice>, INoticeRepository
{
   public NoticeRepository(IDataContext context) : base(context)
   {

   }
...

6) Controller Action

    public ActionResult Create(NoticeViewModel notice)
    {
        notice.TypeId = Convert.ToInt32(NoticeType.ManuallyEnteredDocument);
        var newNotice = AutoMapperService.Map<NoticeViewModel, NoticeDto>(notice);
        NoticeService.Create(newNotice);
        return RedirectToAction("Details", new { name = notice.Arc });
    }

7) NoticeService.Create(new):

    public void Create(NoticeDto notice)
    {
        NoticeDtoValidator.ValidateAndThrow(notice);
        var newNotice = AutoMapperService.Map<NoticeDto, Notice>(notice);
        UnitOfWork.NoticeRepository.Add(newNotice);
        UnitOfWork.SaveChanges();
    }

8) Generic Repository Add():

    public virtual void Add(TEntity entity)
    {
        entity.ObjectState = ObjectState.Added;
        _dbSet.Attach(entity);
        _context.SyncObjectState(entity);
    }

9) UnitOfWork SaveChanges():

    public int SaveChanges()
    {
        return _dataContext.SaveChanges();
    }

When I step through this, the entity that is attached in #8 looks right, the status is added, when save changes is called there are no changes recorded in the base SaveChanges():

    public override int SaveChanges()
    {
        SyncObjectsStatePreCommit();
        base.ChangeTracker.DetectChanges();
        var result = base.ChangeTracker.HasChanges();
        var changes = base.SaveChanges();

result here is false

How could that be? What am I missing, other than abstraction hell and UoW/Repos on top of EF6 context, (I inherited this).

Someone out there see anything ELSE dumb?

No errors, no exceptions, the inserts just don't happen.

Answer 1

Problem solved, the issue was that Ninject was injecting a different context into our repositories.

We found two ways to solve this:

Option 1) In our unit of work we created an additional constructor that just receives a dbcontext and creates new repositories passing them the dbcontext. We left the old constructor as well so we can inject the repos for testing. This worked great and was a trivial change to make.

Option 2) Removed Ninject and overloaded the constructors for each Controller, manually creating the items. Since this project was small, we only had to touch 6 controllers and it worked fine, just 4 new lines of code in each. We left the old constructor as well so we can inject the services for testing.