ASP.Net Core 2+EF Core中模型专属删除代码的最佳放置方案咨询

针对你遇到的问题——禁用懒加载后，手动处理关联实体的级联删除并记录自定义日志，不能依赖数据库级联——我整理了几种可行方案，各有优劣，你可以根据项目规模和架构风格选择：

方案1：模型类中封装删除逻辑（需配合预加载） #

如果你的项目偏向领域驱动设计（DDD），希望实体自己管理生命周期，可以在模型类中编写纯内存的删除方法，业务层负责预加载所有关联数据后调用。

示例代码： #

// 实体类A
public class A
{
    public int Id { get; set; }
    public ICollection<B> Bs { get; set; } = new List<B>();

    // 纯内存删除逻辑，依赖日志接口记录操作
    public void Delete(IDeleteLogger logger)
    {
        // 遍历前转成List，避免集合修改时的遍历异常
        foreach (var b in Bs.ToList())
        {
            b.Delete(logger);
            Bs.Remove(b);
        }
        logger.RecordDelete(nameof(A), Id);
    }
}

// 实体类B
public class B
{
    public int Id { get; set; }
    public ICollection<C> Cs { get; set; } = new List<C>();

    public void Delete(IDeleteLogger logger)
    {
        foreach (var c in Cs.ToList())
        {
            Cs.Remove(c);
            logger.RecordDelete(nameof(C), c.Id);
        }
        logger.RecordDelete(nameof(B), Id);
    }
}

业务层调用： #

public async Task DeleteA(int aId)
{
    using var context = new AppDbContext();
    // 预加载所有需要删除的关联
    var a = await context.As
        .Include(a => a.Bs)
            .ThenInclude(b => b.Cs)
        .FirstOrDefaultAsync(a => a.Id == aId);
    if (a == null) return;

    var logger = new DbDeleteLogger(context); // 自定义日志实现
    a.Delete(logger);

    // 标记所有实体为删除状态并保存
    context.Remove(a);
    await context.SaveChangesAsync();

    // 保存日志到数据库
    await logger.SaveLogsAsync();
}

优缺点： #

• ✅ 实体封装性好，符合DDD思想，调用方无需关注内部关联逻辑
• ✅ 日志记录逻辑与实体删除绑定，不易遗漏
• ❌ 业务层必须记得预加载所有关联，否则会引发空指针或外键异常
• ❌ 数据量大时，加载所有实体可能影响性能

方案2：业务层集中处理删除逻辑 #

如果你的项目更偏向分层架构，希望实体保持纯净（不包含业务逻辑），可以把所有删除、日志逻辑放到业务层（Service）中。

示例代码： #

public class AService
{
    private readonly AppDbContext _context;
    private readonly IDeleteLogger _logger;

    public AService(AppDbContext context, IDeleteLogger logger)
    {
        _context = context;
        _logger = logger;
    }

    public async Task DeleteA(int aId)
    {
        using var transaction = await _context.Database.BeginTransactionAsync();
        
        try
        {
            // 1. 删除所有关联的C
            var cIds = await _context.Cs
                .Where(c => c.B.AId == aId)
                .Select(c => c.Id)
                .ToListAsync();
            await _context.Cs.Where(c => c.B.AId == aId).ExecuteDeleteAsync();
            cIds.ForEach(id => _logger.RecordDelete(nameof(C), id));

            // 2. 删除所有关联的B
            var bIds = await _context.Bs
                .Where(b => b.AId == aId)
                .Select(b => b.Id)
                .ToListAsync();
            await _context.Bs.Where(b => b.AId == aId).ExecuteDeleteAsync();
            bIds.ForEach(id => _logger.RecordDelete(nameof(B), id));

            // 3. 删除A本身
            var a = await _context.As.FindAsync(aId);
            if (a != null)
            {
                _context.Remove(a);
                _logger.RecordDelete(nameof(A), a.Id);
                await _context.SaveChangesAsync();
            }

            // 保存日志
            await _logger.SaveLogsAsync();
            await transaction.CommitAsync();
        }
        catch (Exception)
        {
            await transaction.RollbackAsync();
            throw;
        }
    }
}

优缺点： #

• ✅ 实体类完全纯净，不依赖任何业务或数据访问逻辑
• ✅ 用ExecuteDelete批量删除，性能远优于加载实体后删除，适合大数据量场景
• ✅ 所有逻辑集中在服务层，便于调试和维护
• ❌ 业务层需要硬编码关联关系，后续关联变更时需同步修改代码

方案3：结合显式加载的折中方案 #

如果已经获取了A的实例（比如从上下文缓存中），不想用Include全量预加载，可以用显式加载按需加载关联，再调用实体的删除方法。

示例代码： #

public async Task DeleteA(int aId)
{
    using var context = new AppDbContext();
    var a = await context.As.FindAsync(aId);
    if (a == null) return;

    // 显式加载关联的B
    await context.Entry(a).Collection(a => a.Bs).LoadAsync();
    foreach (var b in a.Bs)
    {
        // 显式加载B关联的C
        await context.Entry(b).Collection(b => b.Cs).LoadAsync();
    }

    var logger = new DbDeleteLogger(context);
    a.Delete(logger);

    context.Remove(a);
    await context.SaveChangesAsync();
    await logger.SaveLogsAsync();
}

优缺点： #

• ✅ 灵活控制加载范围，避免不必要的关联加载
• ✅ 保持实体的封装性，同时不依赖预加载
• ❌ 代码相对繁琐，多了显式加载的步骤
• ❌ 数据量大时性能仍不如批量删除

最终推荐 #

• 如果是小型项目/DDD架构：优先选方案1，兼顾实体封装和代码整洁性
• 如果是大数据量场景：优先选方案2，用批量删除保证性能
• 如果是已有实体实例的场景：用方案3的显式加载来补充

关键注意事项： #

1. 所有删除操作要放在同一个事务中，避免部分删除成功导致数据不一致（EF Core的SaveChanges默认是事务，但批量删除的ExecuteDelete需要手动包裹事务）
2. 日志记录要覆盖所有层级的实体，确保删除轨迹完整
3. 禁用懒加载后，务必确保所有需要操作的关联都已加载，否则会引发NullReferenceException或数据库外键约束异常

内容的提问来源于stack exchange，提问作者markusvt