NET7下EFCORE的通用增删查改类

代码摘录自《深入浅出ASP.NET CORE》

/// <summary>
/// 所有仓储的约定，此接口仅作为约定，用于标识他们
/// </summary>
/// <typeparam name="TEntity">传入仓储的实体模型</typeparam>
/// <typeparam name="TPrimaryKey">传入仓储的主键类型</typeparam>
public interface IRepository<TEntity,TPrimaryKey> where TEntity : class
{
    #region 查询
    IQueryable<TEntity> GetAll();
    List<TEntity> GetAllList();
    Task<List<TEntity>> GetAllListAsync();
    List<TEntity> GetAllList(Expression<Func<TEntity, bool>> predicate);
    Task<List<TEntity>> GetAllListAsync(Expression<Func<TEntity, bool>> predicate);
    TEntity FirstOrDefault(Expression<Func<TEntity, bool>> predicate);
    Task<TEntity> FirstOrDefaultAsycn(Expression<Func<TEntity, bool>> predicate);
    #endregion
 
    #region 新增
    TEntity Insert(TEntity entity);
    Task<TEntity> InsertAsync(TEntity entity);
    #endregion
 
    #region 更新
    TEntity Update(TEntity entity);
    Task<TEntity> UpdateAsync(TEntity entity);
    #endregion
 
    #region 删除
    void Delete(TEntity entity);
    Task DeleteAsync(TEntity entity);
    void Delete(Expression<Func<TEntity, bool>> predicate);
    Task DeleteAsync(Expression<Func<TEntity, bool>> predicate);
    #endregion
 
    #region 总和计算
    int Count();
    Task<int> CountAsync();
    int Count(Expression<Func<TEntity, bool>> predicate);
    Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate);
    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

/// <summary>
/// 默认仓储的通用功能实现，用于所有的领域模型
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <typeparam name="TPrimaryKey"></typeparam>
public class RepositoryBase<TEntity, TPrimaryKey> : IRepository<TEntity, TPrimaryKey> where TEntity : class
{
    protected readonly AppDbContext _appDbContext;
 
    public RepositoryBase(AppDbContext appDbContext)
    {
        _appDbContext = appDbContext;
    }
 
    public virtual DbSet<TEntity> Table=>_appDbContext.Set<TEntity>();
 
    public int Count()
    {
        return GetAll().Count();
    }
 
    public int Count(Expression<Func<TEntity, bool>> predicate)
    {
      return GetAll().Where(predicate).Count();
    }
 
    public async Task<int> CountAsync()
    {
       return await GetAll().CountAsync();
    }
 
    public async Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate)
    {
       return await GetAll().Where(predicate).CountAsync();
    }
 
    public void Delete(TEntity entity)
    {
        AttachIfNot(entity);
        Table.Remove(entity);
        Save();
    }
 
    public async Task DeleteAsync(TEntity entity)
    {
        AttachIfNot(entity);
        Table.Remove(entity);
        await SaveAsync();
    }
 
    public void Delete(Expression<Func<TEntity, bool>> predicate)
    {
        foreach (var entity in GetAll().Where(predicate).ToList())
        {
            Delete(entity);
        }
    }
 
    public async Task DeleteAsync(Expression<Func<TEntity, bool>> predicate)
    {
        foreach (var entity in GetAll().Where(predicate).ToList())
        {
          await  DeleteAsync(entity);
        }
    }
 
    public TEntity FirstOrDefault(Expression<Func<TEntity, bool>> predicate)
    {
       return GetAll().FirstOrDefault(predicate);
    }
 
    public async Task<TEntity> FirstOrDefaultAsycn(Expression<Func<TEntity, bool>> predicate)
    {
       return await GetAll().FirstOrDefaultAsync(predicate);
    }
 
    public IQueryable<TEntity> GetAll()
    {
        return Table.AsQueryable();
    }
 
    public List<TEntity> GetAllList()
    {
       return GetAll().ToList();
    }
 
    public List<TEntity> GetAllList(Expression<Func<TEntity, bool>> predicate)
    {
        return GetAll().Where(predicate).ToList();
    }
 
    public async Task<List<TEntity>> GetAllListAsync()
    {
       return await GetAll().ToListAsync();
    }
 
    public async Task<List<TEntity>> GetAllListAsync(Expression<Func<TEntity, bool>> predicate)
    {
       return await GetAll().Where(predicate).ToListAsync();
    }
 
    public TEntity Insert(TEntity entity)
    {
        var newEntity = Table.Add(entity).Entity;
        Save();
        return newEntity;
    }
 
    protected void Save()
    {
       _appDbContext.SaveChanges();
    }
 
    protected async Task SaveAsync() { 
        await _appDbContext.SaveChangesAsync();
    }
    /// <summary>
    /// 检查实体是否处于跟踪状态，如果是，则返回，如果不是，则添加跟踪状态
    /// </summary>
    /// <param name="entity"></param>
    protected virtual void AttachIfNot(TEntity entity) {
        var entry = _appDbContext.ChangeTracker.Entries().FirstOrDefault(e => e.Entity == entity);
        if (entry != null) { return; }
        Table.Attach(entity);
    }
 
    public async Task<TEntity> InsertAsync(TEntity entity)
    {
        var entityEntry = await Table.AddAsync(entity);
        await SaveAsync();
        return entityEntry.Entity;
    }
 
    public TEntity Update(TEntity entity)
    {
       AttachIfNot(entity);
        _appDbContext.Entry(entity).State = EntityState.Modified;
        Save();
        return entity;
    }
 
    public async Task<TEntity> UpdateAsync(TEntity entity)
    {
        AttachIfNot(entity);
        _appDbContext.Entry(entity).State = EntityState.Modified;
        await SaveAsync();
        return entity;
    }
 
 
}

//假设有一学生接口需要有额外的登录接口，可新建一个IStudent接口，继承后只用加Login接口就行
    public interface IStudentRepository :IRepository<Student, int>
    {
        bool Login(string username, string password);
    }
     
//实现类除了要实现上面的接口，还要继承基类RepositoryBase
    public class StudentRepository : RepositoryBase<Student, int>, IStudentRepository
    {
        public StudentRepository(AppDbContext appDbContext) : base(appDbContext)
        {
        }
 
        public bool Login(string username, string password)
        {
            bool b = false;
            //GetAll是基类中的方法，返回 iquerable
            b = GetAll().Where(a=>a.username=username && a.password=password).Count()>0
            return b;    
        }
    }

//使用记得注入
  services.AddTransient(typeof(IRepository<,>), typeof(RepositoryBase<,>));
 services.AddTransient<IStudentRepository, StudentRepository>();
 
//控制器里的代码
private readonly IRepository<Student, int> _studentRepository;
private readonly IStudentRepository _studentRepository2;
 public WelcomeController(  IRepository<Student, int> studentRepository, IStudentRepository studentRepository2 )
        { 
            _studentRepository = studentRepository; 
            _studentRepository2 = studentRepository2;
        }
        public async Task<IActionResult> Index()
        {
  
 
            //_studentRepository2换成_studentRepository也成，只是没有Login方法
            Models.Student student =  await _studentRepository2.GetAll().FirstOrDefaultAsync();
            int count = await _studentRepository2.CountAsync();
            bool b = _studentRepository2.Login("niunan","123456");
            string str = $"取出一个学生：{student.Name}，学生总数：{count}, 执行login方法结果：{false}";
 
            return Content($"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" /><div>原文：{src}</div><div>加密后：{jiami}</div><div>解密后：{jiemi}</div><div>{str}</div>","text/html");
        }