how wait second operation on my context before first completes with lifestyle PerWebRequest for the context and asynchronous calls to it

Question

My generic repository Interface is:

public interface IGenericRepository<T , TEntityKey> where T : EntityBase<TEntityKey>
{
    IEnumerable<T> GetAll();
    IEnumerable<T> FindBy(Expression<Func<T, bool>> predicate);
    T FindBy(TEntityKey entityKey);
    Task<T> FindByAsync(TEntityKey entityKey);
    T Add(T entity);
    T Delete(T entity);
    void Edit(T entity);
    void Save();
    void Dispose();
}

I used await for all async methods in implementing my repositories. with using Castle Windsor as IOC container, I installed my context with PerWebRequestLifeStyle.

The client sends two requests and each request maps to different repositories implemented by IGenericRepository and this exception rises:

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.

I changed life style of the context to transient but still the exception rises. Can anyone help where I'm wrong?

GenericRepository Implementation:

 public abstract class GenericRepository<T, TEntityKey> : IGenericRepository<T, TEntityKey>
    where T : EntityBase<TEntityKey>
{
    protected IDbContext _entities;
    protected readonly IDbSet<T> _dbset;

    protected GenericRepository(IDbContext context)
    {
        _entities = context;
        _dbset = _entities.Set<T>();
    }

    ~GenericRepository()
    {
        _entities.Dispose();
    }

    public virtual IEnumerable<T> GetAll()
    {
        return _dbset.AsEnumerable<T>();
    }

    public IEnumerable<T> FindBy(System.Linq.Expressions.Expression<Func<T, bool>> predicate)
    {

        IEnumerable<T> query = _dbset.Where(predicate).AsEnumerable();
        return query;
    }

    public T FindBy(TEntityKey entityKey)
    {
        var result = _dbset.SingleOrDefault(e => e.Id.ToString() == entityKey.ToString());
        return result;
    }

    public Task<T> FindByAsync(TEntityKey entityKey)
    {
        var result = _dbset.SingleOrDefaultAsync(e => e.Id.ToString() == entityKey.ToString());
        return result;
    }

    public virtual T Add(T entity)
    {
        return _dbset.Add(entity);
    }

    public virtual T Delete(T entity)
    {
        return _dbset.Remove(entity);
    }

    public virtual void Edit(T entity)
    {
        _entities.Entry(entity).State = EntityState.Modified;
    }

    public virtual void Save()
    {
        _entities.SaveChanges();
    }

    public async Task SaveAsync()
    {
        await _entities.SaveChangesAsync();
    }

    public void Dispose()
    {
        if (_entities != null)
        {
            _entities.Dispose();
            _entities = null;
            GC.SuppressFinalize(this);
        }
    }
}

Answer 1

I think you have some inherited repositories like these:

Public Repository1<Class1, KeyClass1> : GenericRepository<T, TEntityKey>
{
    Public Repository1(IDbContext c) : base(c) { }
}

Public Repository2<Class2, KeyClass2> : GenericRepository<T, TEntityKey>
{
    Public Repository2(IDbContext c) : base(c) { }
}

This means your Castle Windsor will create one instance for IDbContext and injects it into both repositories that causes your error.

I can suggest you to change your base class to this:

public abstract class GenericRepository<T, TEntityKey> : IGenericRepository<T, TEntityKey>
    where T : EntityBase<TEntityKey>
{
    protected IDbContext _entities;
    protected readonly IDbSet<T> _dbset;

    protected GenericRepository()
    {
        _entities = new MyDbContext();
        _dbset = _entities.Set<T>();
    }

    ...
}