为什么某些返回任务的方法在通用存储库模式中未标记为异步

Question

I was reading a really cool article about creating a generic Async repository using the following link https://blog.zhaytam.com/2019/03/14/generic-repository-pattern-csharp/ The interface defines all operations as tasks but the implementation chooses not to use the async/await pattern on a few methods. I'd like to further my understanding of this so decided to post on here. At first glance, it would seem like the client may not know they need to wait for methods that are not marked async, but I probably don't understand this correctly. Can anyone comment as to why the author choose not to use async on some methods that return a task and not others?

public interface IAsyncRepository<T> where T : BaseEntity
{

    Task<T> GetById(int id);
    Task<T> FirstOrDefault(Expression<Func<T, bool>> predicate);

    Task Add(T entity);
    Task Update(T entity);
    Task Remove(T entity);

    Task<IEnumerable<T>> GetAll();
    Task<IEnumerable<T>> GetWhere(Expression<Func<T, bool>> predicate);

    Task<int> CountAll();
    Task<int> CountWhere(Expression<Func<T, bool>> predicate);

}

public class EfRepository<T> : IAsyncRepository<T> where T : BaseEntity
{

    #region Fields

    protected DataDbContext Context;

    #endregion

    public EfRepository(DataDbContext context)
    {
        Context = context;
    }

    #region Public Methods

    public Task<T> GetById(int id) => Context.Set<T>().FindAsync(id);

    public Task<T> FirstOrDefault(Expression<Func<T, bool>> predicate)
        => Context.Set<T>().FirstOrDefaultAsync(predicate);

    public async Task Add(T entity)
    {
        // await Context.AddAsync(entity);
        await Context.Set<T>().AddAsync(entity);
        await Context.SaveChangesAsync();
    }

    public Task Update(T entity)
    {
        // In case AsNoTracking is used
        Context.Entry(entity).State = EntityState.Modified;
        return Context.SaveChangesAsync();
    }

    public Task Remove(T entity)
    {
        Context.Set<T>().Remove(entity);
        return Context.SaveChangesAsync();
    }

    public async Task<IEnumerable<T>> GetAll()
    {
        return await Context.Set<T>().ToListAsync();
    }

    public async Task<IEnumerable<T>> GetWhere(Expression<Func<T, bool>> predicate)
    {
        return await Context.Set<T>().Where(predicate).ToListAsync();
    }

    public Task<int> CountAll() => Context.Set<T>().CountAsync();

    public Task<int> CountWhere(Expression<Func<T, bool>> predicate) 
        => Context.Set<T>().CountAsync(predicate);

    #endregion

}

Answer 1

Notice that the methods have async also have await . In those methods you wait for the to execute to obtain the result, meanwhile in those methods without await you don't care when they will be executed

Answer 2

My suspicion is that it was an accidental omission.

I am having a hard time seeing any benefit to awaiting some of the base class methods and not the others.

Answer 3

Using ONLY the code presented, with the exception of the public async Task Add(T entity) method, the utilisation of "async/await" seems to be completely random.

In all cases, you can either transform the method to async and put a await right before returning, OR you can remove the async and awaits and return the Task .

In the end, the result is the same, both in terms of compiled code as in behaviour in run-time (performance mostly)