使用EFCore封装Service层CRUD代码

在使用asp.net core写后端接口的时候，经常会有很多相似的crud操作，甚至有的接口只需要一行代码就能实现，还要在service层里面定义方法，再来调用，显得很繁琐，因此可以利用c#里面的泛型对service层代码进行封装，写一些通用的crud操作，方便将来进行调用。

public class BaseModel<Key>
{
    [Key]
    public Key Id { get; set; }

}

这个类里面就包含一个主键属性，并且带了一个泛型Key，用来代表主键的类型，因为很多crud操作需要用到主键，因此需要这样定义，其他的实体类需要继承这个基类，比如User类

[Table("sys_user")]
[Comment("用户表")]
public class User:BaseModel<long>
{
    [Comment("用户名")]
    public string UserName { get; set; }

    [Comment("密码")]
    public string Password { get; set; }

    [Comment("邮箱")]
    [EmailAddress]
    public string? Email { get; set; }

    
    public List<Role>? Roles { get; set; }

    internal void Deconstruct(out string userName, out string password)
    {
        (userName, password) = (UserName, Password);
    }
}

public interface IBaseService<T,Key,Context> where T:BaseModel<Key> where Context:DbContext
{
    Context GetContext();

    DbSet<T> GetDbSet();

    /// <summary>
    /// 查询表中所有数据，并返回一个数组
    /// </summary>
    /// <returns></returns>
    Task<T[]> GetAllToArrayAsync();

    /// <summary>
    /// 保存一条记录
    /// </summary>
    /// <param name="entity">需要保存的对象</param>
    /// <returns></returns>
    Task<int> SaveAsync(T entity);

    /// <summary>
    /// 通过主键更新数据
    /// </summary>
    /// <param name="entity">需要更新的对象数据</param>
    /// <returns></returns>
    Task<int> UpdateByIdAsync(T entity);

    /// <summary>
    /// 先检查数据是否存在，再通过主键更新数据
    /// </summary>
    /// <param name="entity">需要更新的对象数据</param>
    /// <param name="notFoundMessage">数据不存在的提示信息</param>
    /// <returns></returns>
    Task<int> UpdateByIdAsync(T entity, string notFoundMessage);

    /// <summary>
    /// 根据主键删除数据
    /// </summary>
    /// <param name="id">主键</param>
    /// <returns></returns>
    Task<int> DeleteByIdAsync(Key id);

    /// <summary>
    /// 先检查数据是否存在，再根据主键删除数据
    /// </summary>
    /// <param name="id">主键</param>
    /// <param name="notFoundMessage">数据不存在的提示信息</param>
    /// <returns></returns>
    Task<int> DeleteByIdAsync(Key id, string notFoundMessage);

    /// <summary>
    /// 根据主键批量删除数据
    /// </summary>
    /// <param name="ids">主键的数组或集合</param>
    /// <returns></returns>
    Task<int> DeleteByIdsAsync(IEnumerable<Key> ids);

    /// <summary>
    /// 先检查数据是否存在，再根据主键批量删除数据
    /// </summary>
    /// <param name="ids">主键的数组或集合</param>
    /// <param name="notFoundMessage">数据都不存在的提示信息</param>
    /// <returns></returns>
    Task<int> DeleteByIdsAsync(IEnumerable<Key> ids,string notFoundMessage);

    /// <summary>
    /// 执行事务操作
    /// </summary>
    /// <param name="execute">在事务中执行的代码</param>
    /// <returns></returns>
    Task ExecuteTransactionAsync(Func<Task> execute);
}

这个接口用到了三个泛型，T表示实体类的类型，必须是BaseModel的子类，Key表示主键类型，Context表示数据库上下文类型，并且定义了很多抽象方法，其中GetContext方法可以返回数据库上下文类型，这意味着可以在controller层通过调用这个方法获取数据库上下文对象，简单的查询只要一行代码就能实现，GetDbSet方法可以返回DbSet对象，其他方法可以根据自己的需要来定义。

public class BaseService<T,Key,Context> : IBaseService<T,Key,Context> where T :BaseModel<Key> where Context:DbContext
{
    protected readonly Context context;

    protected readonly DbSet<T> dbSet;

    public BaseService(Context context, DbSet<T> dbSet)
    {
        this.context = context;
        this.dbSet = dbSet;
    }

    public Context GetContext()
    {
        return context;
    }

    public DbSet<T> GetDbSet()
    {
        return dbSet;
    }

    public Task<int> DeleteByIdAsync(Key id)
    {
        return dbSet.Where(data => data.Id.Equals(id)).ExecuteDeleteAsync();
    }

    public async Task<int> DeleteByIdAsync(Key id, string notFoundMessage)
    {
        var exist = await dbSet.AnyAsync(data => data.Equals(id));
        if (!exist)
        {
            throw new AdminException(notFoundMessage);
        }
        return await dbSet.Where(data => data.Id.Equals(id)).ExecuteDeleteAsync();
    }

    public Task<int> DeleteByIdsAsync(IEnumerable<Key> ids)
    {
        return dbSet.Where(data => ids.Contains(data.Id)).ExecuteDeleteAsync();
    }

    public async Task<int> DeleteByIdsAsync(IEnumerable<Key> ids, string notFoundMessage)
    {
        var exist=await dbSet.AnyAsync(data => ids.Contains(data.Id));
        if (!exist)
        {
            throw new AdminException(notFoundMessage);
        }
        return await dbSet.Where(data => ids.Contains(data.Id)).ExecuteDeleteAsync();
    }

    public Task<T[]> GetAllToArrayAsync()
    {
        return dbSet.ToArrayAsync();
    }
    
    public Task<int> SaveAsync(T entity)
    {
        dbSet.Add(entity);
        return context.SaveChangesAsync();
    }

    public async Task<int> UpdateByIdAsync(T entity, string notFoundMessage)
    {
        var exist = await dbSet.AnyAsync(data => data.Id.Equals(entity.Id));
        if (!exist)
        {
            throw new AdminException(notFoundMessage);
        }
        dbSet.Update(entity);
        return await context.SaveChangesAsync();
    }

    public Task<int> UpdateByIdAsync(T entity)
    {
        dbSet.Update(entity);
        return context.SaveChangesAsync();
    }

    public async Task ExecuteTransactionAsync(Func<Task> execute)
    {
        using var transaction=context.Database.BeginTransaction();
        try
        {
            await execute();
            await transaction.CommitAsync();
        }catch (Exception ex)
        {
            throw ex;
            transaction.RollbackAsync();
        }
    }
}

这个类继承了IBaseService接口，并实现了接口中的方法，其中context和dbSet属性需要通过构造方法传入进来。
下一步就是要继承这些类和接口，进行调用，以用户的crud操作为例

public interface IUserService:IBaseService<User,long,SystemDbContext>
{
    
}

这个接口继承了IBaseService接口，传入了实体类型、主键类型、数据库上下文类型，这三个泛型。前面定义的通用方法可以通过这个接口继承下来，一些复杂的crud操作方法，就需要自己再去定义。

public class UserService : BaseService<User,long,SystemDbContext>,IUserService
{
    public UserService(SystemDbContext context):base(context,context.Users)
    {
        
    }
}

这个类型继承了BaseService类和IUserService接口，并且通过构造方法注入了数据库上下对象，并调用父类的构造方法，将context对象和Dbset对象传给BaseService类
当然，要为这个类注册服务

services.AddScoped<IUserService, UserService>();

[HttpDelete]
public Task<Result<object>> Delete(long[] ids)
{
    return ExecuteCatchAsync(() => userService.DeleteByIdsAsync(ids, "用户不存在"));
}

其中，DeleteByIdsAsync方法就是前面定义的通用crud方法，将来再写其他业务的接口，就不需要再去定义这个方法了。