在Entity Framework中如何结合依赖注入与using语句实现单元测试？

这个问题我之前也碰到过，核心就是要平衡DbContext的资源管理需求和单元测试的可mock性，其实只要调整一下代码结构就能完美解决，咱们一步步来：

1. 先给DbContext做抽象（关键第一步） #

要mock DbContext，首先得把它的行为抽象成接口，这样测试时才能用mock框架替代真实的DbContext。你已经提到了IApplicationDbContext，咱们把它完善一下：

// 定义接口，包含你需要用到的DbSet和方法
public interface IApplicationDbContext
{
    DbSet<OrderingEquipment> OrderingEquipments { get; set; }
    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
    // 其他业务需要的DbSet或DbContext方法都要加到这里
}

// 让你的DbContext实现这个接口
public class ApplicationDbContext : DbContext, IApplicationDbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) 
        : base(options) { }

    public DbSet<OrderingEquipment> OrderingEquipments { get; set; }

    // 实现接口里的其他方法，比如SaveChangesAsync直接复用基类的实现即可
}

2. 通过依赖注入注册DbContext #

在ASP.NET Core（.NET 6+的Program.cs）里注册DbContext和它的接口，让容器管理生命周期：

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// 把接口和具体实现绑定，用Scoped生命周期（和请求周期一致，自动释放资源）
builder.Services.AddScoped<IApplicationDbContext>(provider => 
    provider.GetRequiredService<ApplicationDbContext>());

3. 改造业务代码：去掉手动Using，用注入的方式 #

原来直接new ApplicationDbContext()并包裹using的写法，改成构造函数注入IApplicationDbContext，这样既不用手动管理Dispose，又能方便mock：

public class EquipmentService
{
    private readonly IApplicationDbContext _dbContext;

    // 构造函数注入接口
    public EquipmentService(IApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<List<OrderingEquipment>> GetAllEquipmentsAsync()
    {
        // 这里不用写using了！DI容器会在作用域结束时自动释放DbContext
        return await _dbContext.OrderingEquipments.ToListAsync();
    }
}

为什么不用手动using？因为ASP.NET Core的Scoped生命周期会在每个请求结束后自动调用DbContext的Dispose方法，和using的资源释放效果完全一致，但更灵活。

4. 单元测试：Mock DbContext和DbSet #

用Moq框架就能轻松mockIApplicationDbContext和里面的DbSet，返回模拟数据。这里需要几个辅助类来支持EF的异步查询：

测试代码示例 #

[TestClass]
public class EquipmentServiceTests
{
    [TestMethod]
    public async Task GetAllEquipmentsAsync_ReturnsMockedData()
    {
        // 1. 准备模拟的设备数据
        var mockEquipments = new List<OrderingEquipment>
        {
            new() { Id = 1, Name = "测试设备1" },
            new() { Id = 2, Name = "测试设备2" }
        };

        // 2. Mock DbSet，让它支持异步查询
        var mockDbSet = new Mock<DbSet<OrderingEquipment>>();
        mockDbSet.As<IAsyncEnumerable<OrderingEquipment>>()
            .Setup(m => m.GetAsyncEnumerator(It.IsAny<CancellationToken>()))
            .Returns(new TestAsyncEnumerator<OrderingEquipment>(mockEquipments.GetEnumerator()));

        mockDbSet.As<IQueryable<OrderingEquipment>>()
            .Setup(m => m.Provider)
            .Returns(new TestAsyncQueryProvider<OrderingEquipment>(mockEquipments.AsQueryable().Provider));

        mockDbSet.As<IQueryable<OrderingEquipment>>()
            .Setup(m => m.Expression)
            .Returns(mockEquipments.AsQueryable().Expression);
        mockDbSet.As<IQueryable<OrderingEquipment>>()
            .Setup(m => m.ElementType)
            .Returns(mockEquipments.AsQueryable().ElementType);
        mockDbSet.As<IQueryable<OrderingEquipment>>()
            .Setup(m => m.GetEnumerator())
            .Returns(mockEquipments.GetEnumerator());

        // 3. Mock DbContext，返回刚才的Mock DbSet
        var mockDbContext = new Mock<IApplicationDbContext>();
        mockDbContext.Setup(m => m.OrderingEquipments).Returns(mockDbSet.Object);

        // 4. 创建服务实例，传入Mock的DbContext
        var service = new EquipmentService(mockDbContext.Object);

        // 5. 调用方法并断言结果
        var result = await service.GetAllEquipmentsAsync();
        Assert.AreEqual(2, result.Count);
        Assert.AreEqual("测试设备1", result[0].Name);
    }
}

// 辅助类：支持EF异步查询的Mock实现
public class TestAsyncEnumerator<T> : IAsyncEnumerator<T>
{
    private readonly IEnumerator<T> _innerEnumerator;

    public TestAsyncEnumerator(IEnumerator<T> inner) => _innerEnumerator = inner;

    public ValueTask DisposeAsync()
    {
        _innerEnumerator.Dispose();
        return ValueTask.CompletedTask;
    }

    public ValueTask<bool> MoveNextAsync() 
        => new ValueTask<bool>(_innerEnumerator.MoveNext());

    public T Current => _innerEnumerator.Current;
}

public class TestAsyncQueryProvider<T> : IAsyncQueryProvider
{
    private readonly IQueryProvider _innerProvider;

    public TestAsyncQueryProvider(IQueryProvider inner) => _innerProvider = inner;

    public IQueryable CreateQuery(Expression expression) 
        => new TestAsyncEnumerable<T>(expression);

    public IQueryable<TElement> CreateQuery<TElement>(Expression expression) 
        => new TestAsyncEnumerable<TElement>(expression);

    public object Execute(Expression expression) => _innerProvider.Execute(expression);

    public TResult Execute<TResult>(Expression expression) 
        => _innerProvider.Execute<TResult>(expression);

    public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression) 
        => new TestAsyncEnumerable<TResult>(expression);

    public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken) 
        => Task.FromResult(Execute<TResult>(expression));
}

public class TestAsyncEnumerable<T> : EnumerableQuery<T>, IAsyncEnumerable<T>, IQueryable<T>
{
    public TestAsyncEnumerable(IEnumerable<T> enumerable) : base(enumerable) { }
    public TestAsyncEnumerable(Expression expression) : base(expression) { }

    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default) 
        => new TestAsyncEnumerator<T>(AsEnumerable().GetEnumerator());

    IQueryProvider IQueryable.Provider => new TestAsyncQueryProvider<T>(this);
}

额外场景：非ASP.NET Core环境的资源管理 #

如果是控制台、桌面应用这类没有自动请求作用域的场景，你可以手动创建依赖注入作用域，用using包裹来确保资源释放：

using (var scope = serviceProvider.CreateScope())
{
    var dbContext = scope.ServiceProvider.GetRequiredService<IApplicationDbContext>();
    // 执行数据库操作
}

这样既保留了依赖注入的灵活性，又能像原来的using一样确保DbContext被正确释放。

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