基于Entity Framework的仓储模式：多表查询与DbContext生命周期难题

这个问题是EF仓储模式中非常典型的DbContext生命周期管理痛点，我来给你梳理下最优的解决方案——工作单元模式（Unit of Work），完美覆盖你提到的所有需求：

核心思路 #

工作单元的本质是统一管理DbContext的生命周期，让多个仓储共享同一个DbContext实例，直到整个业务操作完成后再释放。这样既解决了IQueryable延迟加载时DbContext提前释放的问题，又避免了长期持有DbContext带来的缓存失效、不符合规范的问题，同时还能轻松支持多表关联查询。

具体实现步骤 #

1. 定义工作单元接口 #

先抽象出IUnitOfWork接口，负责仓储的获取、事务提交和资源释放：

public interface IUnitOfWork : IDisposable
{
    // 获取指定实体的仓储
    IRepository<TEntity> GetRepository<TEntity>() where TEntity : class;
    // 统一提交所有更改
    int SaveChanges();
}

2. 实现EF版本的工作单元 #

基于Entity Framework实现IUnitOfWork，内部持有一个DbContext实例，为所有仓储共享：

public class EfUnitOfWork : IUnitOfWork
{
    private readonly DatabaseContext _dbContext;
    private readonly Dictionary<Type, object> _repositories = new();

    // 通过构造注入DbContext，避免在内部创建
    public EfUnitOfWork(DatabaseContext dbContext)
    {
        _dbContext = dbContext;
    }

    public IRepository<TEntity> GetRepository<TEntity>() where TEntity : class
    {
        // 复用已创建的仓储实例
        if (_repositories.ContainsKey(typeof(TEntity)))
        {
            return (IRepository<TEntity>)_repositories[typeof(TEntity)];
        }

        var repository = new EfRepository<TEntity>(_dbContext);
        _repositories.Add(typeof(TEntity), repository);
        return repository;
    }

    public int SaveChanges()
    {
        // 统一提交所有仓储的更改，保证事务原子性
        return _dbContext.SaveChanges();
    }

    public void Dispose()
    {
        // 释放DbContext资源
        _dbContext.Dispose();
        GC.SuppressFinalize(this);
    }
}

3. 修改泛型仓储实现 #

让仓储依赖注入DbContext，不再自行创建或using包裹：

public class EfRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
    protected readonly DatabaseContext _dbContext;
    protected readonly DbSet<TEntity> _dbSet;

    public EfRepository(DatabaseContext dbContext)
    {
        _dbContext = dbContext;
        _dbSet = dbContext.Set<TEntity>();
    }

    public TEntity Get(int id)
    {
        return _dbSet.Find(id);
    }

    public void Add(TEntity entity)
    {
        _dbSet.Add(entity);
    }

    public IQueryable<TEntity> GetAll()
    {
        // 返回IQueryable，延迟加载由工作单元的DbContext生命周期保证
        return _dbSet.AsQueryable();
    }

    // 其他仓储方法（如Update、Delete等）同理实现
}

4. 业务层使用示例 #

在业务逻辑中通过工作单元获取仓储，完成多表关联查询或批量操作：

public class SomethingService
{
    private readonly IUnitOfWork _unitOfWork;

    // 构造注入工作单元
    public SomethingService(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }

    public AnotherThing ReturnAnotherThingWithRelatedData()
    {
        var anotherThingRepo = _unitOfWork.GetRepository<AnotherThing>();
        
        // 多表关联查询，DbContext直到工作单元释放才会被销毁，IQueryable可正常执行
        var result = anotherThingRepo.GetAll()
            .Include(at => at.RelatedEntities) // 手动包含关联字段（如果关闭延迟加载）
            .Where(at => at.Status == "Active")
            .SingleOrDefault();

        return result;
    }

    public void SaveMultiEntities()
    {
        var firstRepo = _unitOfWork.GetRepository<FirstThing>();
        var secondRepo = _unitOfWork.GetRepository<SecondThing>();

        // 添加多个实体
        firstRepo.Add(new FirstThing { Name = "Test1" });
        secondRepo.Add(new SecondThing { Description = "Test2" });

        // 统一提交，保证两个操作在同一个事务中
        _unitOfWork.SaveChanges();
    }
}

5. 依赖注入配置（以ASP.NET Core为例） #

将DbContext和工作单元注册为Scoped生命周期（每个请求一个实例），自动管理资源：

services.AddDbContext<DatabaseContext>(options => 
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddScoped<IUnitOfWork, EfUnitOfWork>();

为什么这个方案解决了你的所有痛点？ #

• IQueryable延迟加载问题：DbContext由工作单元持有，直到整个业务操作完成才释放，IQueryable执行时上下文仍存活。
• 多表关联查询：支持Include或延迟加载关联字段，无需返回List/IEnumerable牺牲灵活性。
• DbContext缓存问题：每个业务操作（或请求）对应一个独立的DbContext实例，用完即释放，避免长期缓存导致的更新失效。
• 可扩展性：替换数据库提供商时，只需实现对应ORM的IUnitOfWork和IRepository，业务层无需修改；测试时可轻松模拟工作单元和仓储，用内存数据库或Mock对象替代真实数据库。

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