c# - A second operation started on this context before a previous asynchronous operation completed with UnitofWork and async

Question

A second operation started on this context before a previous asynchronous operation completed. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. Any instance members are not guaranteed to be thread safe.

My unitofwork code

 public class UnitOfWork : IUnitOfWork
    {
        private readonly CAMSDbEntities _context;
        private bool _disposed;
        public Dictionary<Type, object> repositories = new Dictionary<Type, object>();
        private Guid _objectId;

        public UnitOfWork(IContextFactory contextFactory)
        {
            _context = contextFactory.DbContext as CAMSDbEntities;
            _objectId = Guid.NewGuid();
        }

        public IGenericRepository<T> Repository<T>() where T : class
        {
            if (repositories.Keys.Contains(typeof(T)) == true)
            {
                return repositories[typeof(T)] as GenericRepository<T>;
            }
            GenericRepository<T> repo = new GenericRepository<T>(_context);
            repositories.Add(typeof(T), repo);
            return repo;
        }

My unity config

      container.RegisterType<IHttpContext, HttpContextObject>();
                container.RegisterType<IDataBaseManager, DataBaseManager>();
                container.RegisterType<IContextFactory, ContextFactory>();

                container.RegisterType(typeof(IGenericRepository<>), typeof(GenericRepository<>));

                container.RegisterType<IUnitOfWork, UnitOfWork>();

                container.RegisterType<IAnalytics, DashbordService>();
    GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);

webApi Controller

 public class DashbordController : ApiController
        {
            private static IAnalytics _analytics;
            public DashbordController(IAnalytics dashbordService)
            {
                _analytics = dashbordService;
            }

            [HttpGet]
            [Route("GetStudentAssessmentHistory")]
            public IHttpActionResult GetStudentAssessmentHistory(int studentID)
            {
                var result = _analytics.GetStudentAssessmentHistoryGraphData(studentID);
                return Ok(result);
            }

            [HttpGet]
            [Route("GetStudentFeePaymentHistory")]
            public async Task<IHttpActionResult> GetStudentFeePaymentData(int studentID)
            {
                var result = await _analytics.GetStudentFeePaymentData(studentID);
                return Ok(result);
            }

            [HttpGet]
            [Route("GetLedgerHitoryByDepartment")]
            public async Task<IHttpActionResult> GetLedgerHitoryByDepartment(int schoolID, int departmentId)
            {
                var result = await _analytics.GetLedgerHitory(schoolID, departmentId);
                return Ok(result);
            }

            [HttpGet]
            [Route("GetLedgerExpenseTrendByDepartment")]
            public async Task<IHttpActionResult> GetLedgerExpenseTrendByDepartment(int schoolID)
            {
                var result = await _analytics.GetLedgerExpenseTrend(schoolID);
                return Ok(result);
            }

dashboardservice Code

  public async Task<List<LedgerExpense>> GetLedgerExpenseTrend(int schoolId)
        {
            try
            {
                var ledgerExpenses = new List<LedgerExpense>();
                var currentDate = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, INDIAN_ZONE);
                DateTime previoYearDate = currentDate.AddYears(-1);
                var ledgerPayments = await  _unitOfWork.Repository<LedgerDetail>().GetManyAsync(x => x.SchoolID == schoolId && x.PaymentDate <= currentDate
                                                       && x.PaymentDate >= previoYearDate);

                foreach (var ledgerPayment in ledgerPayments.OrderBy(x => x.PaymentDate).GroupBy(y => y.DepartmentID))
                {
                    var department = await  _unitOfWork.Repository<DeptartmentType>().GetAsync(x => x.ID == ledgerPayment.Key);

                    var ledgerData = new LedgerExpense
                    {
                        Department = department.DepartmentName,
                        TotalLedgerExpense = 0
                    };

                    foreach (var departmentPayment in ledgerPayment)
                    {
                        ledgerData.TotalLedgerExpense += departmentPayment.TotalPaidAmount;
                    }

                    ledgerExpenses.Add(ledgerData);
                }

                return ledgerExpenses;
            }
            catch (Exception ex)
            {
                logger.Log("An error occurred while fetching ledger expenses");
                return null;
            }
        }

I have similar type of asynchronous metods implemented in my dashboardservice code. whenever I request a dashboard UI all request comes to the same controller at the same time and creates the new object for unitofwork and dbcontext for each request one by one. it works perfectly sometimes but Sometimes I think unitofwork and dbcontext object flows with the wrong thread and throws this error. I think somehow its picking wrong dbcontext which is already busy with someother api request from dashboard service.

Answer 1

Please remove the static keyword in your controller from this code:

private static IAnalytics _analytics;`

Once that has been created, it will never be created again unless the application pool is recycled (manual or IIS restart etc.) Since you are using the same instance for all requests, you are getting that error at random. If a request finishes before the next one arrives, it will NOT result in an error. Otherwise it will. Hence the reason for not always getting the error (as you mention in your question).

Please read about how static affects the design in a web scenario (or server).

Try and think of web requests as a single transaction, all classes are created for each request and then thrown away after the request has been served. That means if you have static or any other mechanism which is for sharing, it will be shared between requests.