实体框架通用存储库模式异步添加方法和保存

Question

I have a base repository class called Repository. Can anyone explain me how should I make methods in this class async?

public abstract class Repository<TEntity> : IRepository<TEntity> where TEntity : Entity
{
    private readonly DbContext _context;
    private readonly DbSet<TEntity> _dbSet;

    public Repository(DbContext context)
    {
        _context = context;
        _dbSet = context.Set<TEntity>();
    }
    public TEntity Add(TEntity entity)
    {
        entity.CreateDate = DateTime.Now;
        _dbSet.Add(entity);
        Save();
        return entity;
    }
    public void Save()
    {
        _context.SaveChanges();
    }
}

I tried to make it asynchronous, but I couldn't decide how both the adding and saving method will be asynchronous at the same time. My experiment is here and it doesn't look right because it contains two await.

public abstract class Repository<TEntity> : IRepository<TEntity> where TEntity : Entity
{
    private readonly DbContext _context;
    private readonly DbSet<TEntity> _dbSet;

    public Repository(DbContext context)
    {
        _context = context;
        _dbSet = context.Set<TEntity>();
    }

    public async Task<TEntity> AddAsync(TEntity entity)
    {
        entity.CreateDate = DateTime.Now;
        await _dbSet.AddAsync(entity);
        await SaveAsync();
        return entity;
    }

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

Answer 1

Actually, your base repository is not wrong, but unfortunately, most of us are using the Asynchronous programming and Async, await manner without a deep understanding. I recommend visiting this link Asynchronous Programming , anyway

1. The await operator is applied to a task in an asynchronous method, and a hanging start point is inserted in the execution of the method until the waiting task is completed. The task indicates the work in progress.

2 、await only can be used in asynchronous methods modified by the async keyword. This type of method, defined with the async modifier and usually containing one or more await expressions, is called an asynchronous method.

3 , the only purpose of await is to suspend this method when calling the asynchronous method XXAsync(). It considers this method to be a time-consuming method, the main thread, or the thread that calls this method. Do not wait in this way. and mark it at the same time. When the currently executing thread finishes running, it will resume running from here, so the code or method below the await tag's asynchronous method will not run. You must wait for this method. carry out!

4 , plus or not await, and whether the method is asynchronous or synchronous does not matter Write an example below

 private static async Task XAsync()
  {            
     await  XXAsync();
     OtherMothod();   
  }

5 . When running to await XXAsync(), the call to method XAsync() will no longer run and return directly, just like the return statement in our program code. The advantage of this is that the calling thread will not wait for this time-consuming thread. Directly let the calling thread run down,

6 . If the calling thread always has the await chain up, just like the return in the method set method, it will return upwards layer by layer, returning to the main thread, and each "child thread" Wait for time-consuming I/O processing, such as manipulating databases and network flows

7 . We want to execute our program in multi-threaded or multi-tasking, let the time-consuming task get executed, and at the same time give the caller a quick response, no matter whether he has completed the task. It is the real purpose.

private static async TaskXAsync()
  {
           
    await  XXAsync();

    await  XXXAsync(); 
  }

XXXAsync() must wait for the XXAsync() method to execute, This will not affect the caller's response speed, but it will affect the execution efficiency of our code. which is slightly different from the two synchronization methods.

private static async TaskXAsync()
  {
           
    XX();

    XXX(); 
  }

Like the above examples XX () and XXX () two synchronization methods, not only in order but the caller can not get the call right, that is, can not respond in time, must wait until both methods are finished. I hope that would be helpful

Answer 2

public interface IRepository<TEntity> where TEntity : class
{
    IQueryable<TEntity> GetAll();
    IQueryable<TEntity> GetByWhere(Expression<Func<TEntity, bool>> predicate);
   
    Task CreateAsync(TEntity entity);

    Task UpdateAsync(TEntity entity);

    Task DeleteAsync(TEntity entity);
}

 
       public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
        {
            private readonly DbContext dbContext;
    
            public Repository(DbContext dbContext)
            {
                this.dbContext = dbContext;
            }
    
            public async Task CreateAsync(TEntity entity)
            {
                await dbContext.Set<TEntity>().AddAsync(entity);
                await dbContext.SaveChangesAsync();
            }
    
            public async Task DeleteAsync(TEntity entity)
            {
                dbContext.Set<TEntity>().Remove(entity);
                await dbContext.SaveChangesAsync();
            }
    

    
            public IQueryable<TEntity> GetAll()
            {
                return dbContext.Set<TEntity>().AsNoTracking();
            }
    
            public IQueryable<TEntity> GetByWhere(System.Linq.Expressions.Expression<Func<TEntity, bool>> predicate)
            {
                return dbContext.Set<TEntity>().Where(predicate).AsNoTracking();
            }
    
            public async Task UpdateAsync(TEntity entity)
            {
                dbContext.Update(entity);
                await dbContext.SaveChangesAsync();
            }
        }