重构仓库结构：移动 IBaseRepository 到 Domain 层并更新相关接口

2 months ago · 01bf2e727c
7 changed files with 249 additions and 77 deletions
--- a/src/CellularManagement.Domain/Repositories/IBaseRepository.cs
+++ b/src/CellularManagement.Domain/Repositories/IBaseRepository.cs
@ -0,0 +1,229 @@
+using CellularManagement.Domain.Repositories;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+/// <summary>
+/// 基础仓储接口
+/// 组合命令和查询仓储的功能
+/// </summary>
+/// <typeparam name="T">实体类型</typeparam>
+namespace CellularManagement.Domain.Repositories
+{
+    public interface IBaseRepository<T> where T : class
+    {
+        // <summary>
+        /// 添加单个实体到数据库
+        /// </summary>
+        /// <param name="entity">要添加的实体</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>添加后的实体</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的插入操作完成
+        /// 实体添加后，其ID和其他数据库生成的字段会被填充
+        /// </remarks>
+        Task<T> AddAsync(T entity, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 批量添加多个实体到数据库
+        /// </summary>
+        /// <param name="entities">要添加的实体集合</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>添加后的实体集合</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的批量插入操作完成
+        /// 批量添加比逐个添加更高效，特别是在大量数据时
+        /// </remarks>
+        Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 更新单个实体的状态
+        /// </summary>
+        /// <param name="entity">要更新的实体</param>
+        /// <remarks>
+        /// 这是一个同步操作，因为它只是标记实体的状态为已修改
+        /// 实际的数据库更新操作由 UnitOfWork 在事务提交时执行
+        /// </remarks>
+        void Update(T entity);
+
+        /// <summary>
+        /// 批量更新多个实体的状态
+        /// </summary>
+        /// <param name="entities">要更新的实体集合</param>
+        /// <remarks>
+        /// 这是一个同步操作，因为它只是标记实体的状态为已修改
+        /// 批量更新比逐个更新更高效，特别是在大量数据时
+        /// </remarks>
+        void UpdateRange(IEnumerable<T> entities);
+
+        /// <summary>
+        /// 删除单个实体
+        /// </summary>
+        /// <param name="entity">要删除的实体</param>
+        /// <remarks>
+        /// 这是一个同步操作，因为它只是标记实体的状态为已删除
+        /// 实际的数据库删除操作由 UnitOfWork 在事务提交时执行
+        /// 如果实体实现了 ISoftDelete 接口，将执行软删除
+        /// </remarks>
+        void Delete(T entity);
+
+        /// <summary>
+        /// 批量删除多个实体
+        /// </summary>
+        /// <param name="entities">要删除的实体集合</param>
+        /// <remarks>
+        /// 这是一个同步操作，因为它只是标记实体的状态为已删除
+        /// 批量删除比逐个删除更高效，特别是在大量数据时
+        /// </remarks>
+        void DeleteRange(IEnumerable<T> entities);
+
+        /// <summary>
+        /// 根据ID删除实体
+        /// </summary>
+        /// <param name="id">要删除的实体的ID</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>是否成功找到并删除实体</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要先查询数据库找到实体
+        /// 如果实体不存在，返回 false
+        /// 如果实体存在，将其标记为已删除
+        /// </remarks>
+        Task<bool> DeleteByIdAsync(string id, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 根据条件删除实体
+        /// </summary>
+        /// <param name="predicate">删除条件表达式</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>删除的实体数量</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要先查询数据库找到符合条件的实体
+        /// 使用 LINQ 表达式树构建查询条件
+        /// 返回实际删除的实体数量
+        /// </remarks>
+        Task<int> DeleteWhereAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default);
+
+
+        /// <summary>
+        /// 根据ID查询单个实体
+        /// </summary>
+        /// <param name="id">要查询的实体ID</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>查询到的实体，如果不存在则返回 null</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的查询操作完成
+        /// 使用主键进行查询，性能最优
+        /// </remarks>
+        Task<T?> GetByIdAsync(string id, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 查询所有实体
+        /// </summary>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>所有实体的集合</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的查询操作完成
+        /// 注意：对于大数据量的表，建议使用分页查询
+        /// </remarks>
+        Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 根据条件查询实体
+        /// </summary>
+        /// <param name="predicate">查询条件表达式</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>符合条件的实体集合</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的查询操作完成
+        /// 使用 LINQ 表达式树构建查询条件
+        /// 条件查询会被转换为 SQL 语句在数据库端执行
+        /// </remarks>
+        Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 分页查询实体
+        /// </summary>
+        /// <param name="pageNumber">页码，从1开始</param>
+        /// <param name="pageSize">每页记录数</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>分页查询结果，包含总记录数和当前页数据</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的查询操作完成
+        /// 分页查询可以有效减少数据传输量，提高性能
+        /// 建议在查询大数据量时使用
+        /// </remarks>
+        Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 根据条件分页查询实体
+        /// </summary>
+        /// <param name="predicate">查询条件表达式</param>
+        /// <param name="pageNumber">页码，从1开始</param>
+        /// <param name="pageSize">每页记录数</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>分页查询结果，包含总记录数和当前页数据</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的查询操作完成
+        /// 结合条件查询和分页查询，适用于大数据量的条件筛选
+        /// </remarks>
+        Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(
+            Expression<Func<T, bool>> predicate,
+            int pageNumber,
+            int pageSize,
+            CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 查询单个实体
+        /// </summary>
+        /// <param name="predicate">查询条件表达式</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>查询到的实体，如果不存在则返回 null</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的查询操作完成
+        /// 如果查询结果包含多个实体，将返回第一个
+        /// 建议在确定只会返回一个结果时使用
+        /// </remarks>
+        Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 查询实体是否存在
+        /// </summary>
+        /// <param name="predicate">查询条件表达式</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>是否存在符合条件的实体</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的查询操作完成
+        /// 使用 EXISTS 语句在数据库端执行，性能优于获取完整实体
+        /// </remarks>
+        Task<bool> AnyAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 统计符合条件的实体数量
+        /// </summary>
+        /// <param name="predicate">查询条件表达式</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>符合条件的实体数量</returns>
+        /// <remarks>
+        /// 这是一个异步操作，因为需要等待数据库的查询操作完成
+        /// 使用 COUNT 语句在数据库端执行，性能优于获取完整实体
+        /// </remarks>
+        Task<int> CountAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 执行SQL复制查询
+        /// </summary>
+        /// <param name="sql">SQL查询语句</param>
+        /// <param name="parameters">SQL参数</param>
+        /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
+        /// <returns>查询结果集合</returns>
+        /// <remarks>
+        /// 这是一个异步操作，用于执行自定义SQL查询
+        /// 支持参数化查询，防止SQL注入
+        /// 返回的结果会被映射到实体类型T
+        /// </remarks>
+        Task<IEnumerable<T>> ExecuteSqlQueryAsync(string sql, object[] parameters, CancellationToken cancellationToken = default);
+    }
+}
+
--- a/src/CellularManagement.Domain/Repositories/ICellularDeviceRepository.cs
+++ b/src/CellularManagement.Domain/Repositories/ICellularDeviceRepository.cs
@ -4,11 +4,12 @@ using CellularManagement.Domain.Entities.Device;
 namespace CellularManagement.Domain.Repositories;

 /// <summary>
-/// 蜂窝设备命令仓储接口
-/// 负责蜂窝设备的写入操作
+/// 蜂窝设备仓储接口
+/// 组合命令和查询仓储接口
 /// </summary>
-public interface ICellularDeviceCommandRepository : ICommandRepository<CellularDevice>
+public interface ICellularDeviceRepository : IBaseRepository<CellularDevice>
 {
+
    /// <summary>
    /// 添加蜂窝设备
    /// </summary>
@ -38,14 +39,7 @@ public interface ICellularDeviceCommandRepository : ICommandRepository<CellularD
    /// 批量删除蜂窝设备
    /// </summary>
    Task DeleteDevicesAsync(IEnumerable<string> ids, CancellationToken cancellationToken = default);
-}

-/// <summary>
-/// 蜂窝设备查询仓储接口
-/// 负责蜂窝设备的读取操作
-/// </summary>
-public interface ICellularDeviceQueryRepository : IQueryRepository<CellularDevice>
-{
    /// <summary>
    /// 获取所有蜂窝设备
    /// </summary>
@ -90,11 +84,3 @@ public interface ICellularDeviceQueryRepository : IQueryRepository<CellularDevic
    /// </summary>
    Task<bool> SerialNumberExistsAsync(string serialNumber, CancellationToken cancellationToken = default);
 } 
-
-/// <summary>
-/// 蜂窝设备仓储接口
-/// 组合命令和查询仓储接口
-/// </summary>
-public interface ICellularDeviceRepository : ICellularDeviceCommandRepository, ICellularDeviceQueryRepository
-{
-} 
--- a/src/CellularManagement.Domain/Repositories/ILoginLogRepository.cs
+++ b/src/CellularManagement.Domain/Repositories/ILoginLogRepository.cs
@ -8,7 +8,7 @@ namespace CellularManagement.Domain.Repositories;
 /// <summary>
 /// 登录日志仓储接口
 /// </summary>
-public interface ILoginLogRepository : ICommandRepository<LoginLog>, IQueryRepository<LoginLog>
+public interface ILoginLogRepository : IBaseRepository<LoginLog>
 {
    /// <summary>
    /// 添加登录日志
--- a/src/CellularManagement.Domain/Repositories/IPermissionRepository.cs
+++ b/src/CellularManagement.Domain/Repositories/IPermissionRepository.cs
@ -6,11 +6,16 @@ using CellularManagement.Domain.Entities;
 namespace CellularManagement.Domain.Repositories;

 /// <summary>
-/// 权限命令仓储接口
-/// 负责权限的写入操作
+/// 权限仓储接口
+/// 组合命令和查询仓储接口
 /// </summary>
-public interface IPermissionCommandRepository : ICommandRepository<Permission>
+public interface IPermissionRepository : IBaseRepository<Permission>
 {
+    /// <summary>
+    /// 根据名称获取权限
+    /// </summary>
+    Task<Permission?> GetByNameAsync(string name, CancellationToken cancellationToken = default);
+
    /// <summary>
    /// 更新权限
    /// </summary>
@ -21,24 +26,3 @@ public interface IPermissionCommandRepository : ICommandRepository<Permission>
    /// </summary>
    Task DeleteAsync(Permission permission, CancellationToken cancellationToken = default);
 } 
-
-/// <summary>
-/// 权限查询仓储接口
-/// 负责权限的读取操作
-/// </summary>
-public interface IPermissionQueryRepository : IQueryRepository<Permission>
-{
-    /// <summary>
-    /// 根据名称获取权限
-    /// </summary>
-    Task<Permission?> GetByNameAsync(string name, CancellationToken cancellationToken = default);
-}
-
-/// <summary>
-/// 权限仓储接口
-/// 组合命令和查询仓储接口
-/// </summary>
-public interface IPermissionRepository : IPermissionCommandRepository, IPermissionQueryRepository
-{
-
-} 
--- a/src/CellularManagement.Domain/Repositories/IRolePermissionRepository.cs
+++ b/src/CellularManagement.Domain/Repositories/IRolePermissionRepository.cs
@ -6,7 +6,7 @@ namespace CellularManagement.Domain.Repositories;
 /// 角色权限仓储接口
 /// 遵循 DDD 设计模式，提供角色权限相关的领域操作
 /// </summary>
-public interface IRolePermissionRepository : ICommandRepository<RolePermission>, IQueryRepository<RolePermission>
+public interface IRolePermissionRepository : IBaseRepository <RolePermission>
 {
    /// <summary>
    /// 根据角色ID获取所有权限
--- a/src/CellularManagement.Domain/Repositories/IUserRoleRepository.cs
+++ b/src/CellularManagement.Domain/Repositories/IUserRoleRepository.cs
@ -5,11 +5,12 @@ using CellularManagement.Domain.Entities;

 namespace CellularManagement.Domain.Repositories;

+
 /// <summary>
-/// 用户角色命令仓储接口
-/// 负责用户角色关系的写入操作
+/// 用户角色仓储接口
+/// 组合命令和查询仓储接口
 /// </summary>
-public interface IUserRoleCommandRepository : ICommandRepository<UserRole>
+public interface IUserRoleRepository : IBaseRepository<UserRole>
 {
    /// <summary>
    /// 添加用户角色关系
@ -30,14 +31,8 @@ public interface IUserRoleCommandRepository : ICommandRepository<UserRole>
    /// 批量删除用户角色关系
    /// </summary>
    Task DeleteUserRolesAsync(string userId, IEnumerable<string> roleIds, CancellationToken cancellationToken = default);
-}

-/// <summary>
-/// 用户角色查询仓储接口
-/// 负责用户角色关系的读取操作
-/// </summary>
-public interface IUserRoleQueryRepository : IQueryRepository<UserRole>
-{
+
    /// <summary>
    /// 获取用户的所有角色
    /// </summary>
@ -58,12 +53,3 @@ public interface IUserRoleQueryRepository : IQueryRepository<UserRole>
    /// </summary>
    Task<UserRole?> GetUserRoleAsync(string userId, string roleId, CancellationToken cancellationToken = default);
 }
-
-/// <summary>
-/// 用户角色仓储接口
-/// 组合命令和查询仓储接口
-/// </summary>
-public interface IUserRoleRepository : IUserRoleCommandRepository, IUserRoleQueryRepository
-{
-
-} 
--- a/src/CellularManagement.Infrastructure/Repositories/Base/IBaseRepository.cs
+++ b/src/CellularManagement.Infrastructure/Repositories/Base/IBaseRepository.cs
@ -1,13 +0,0 @@
-using CellularManagement.Domain.Repositories;
-
-namespace CellularManagement.Infrastructure.Repositories.Base;
-
-/// <summary>
-/// 基础仓储接口
-/// 组合命令和查询仓储的功能
-/// </summary>
-/// <typeparam name="T">实体类型</typeparam>
-public interface IBaseRepository<T> : ICommandRepository<T>, IQueryRepository<T> where T : class
-{
-
-}