看起来你已经走对了方向，只是卡在了如何提供一个不依赖真实数据库的DbContext实例上。针对你的分层架构（Database=>EF=>Repository=>Logic=>Display），有几种可靠的方法来测试CRUD操作，完全不需要真实数据库或连接字符串，我来一步步给你讲清楚：

方法1：使用EF Core内存数据库（最推荐，适合EF Core项目） #

如果你的项目用的是EF Core，官方提供的内存数据库提供程序是最优解——它完全模拟了真实数据库的行为，支持LINQ查询、SaveChanges等核心操作，而且不需要任何连接字符串，数据只存在于内存中，测试结束后自动销毁。

示例代码 #

首先假设你的实际DbContext定义如下（如果已有，直接用你自己的即可）：

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
    public DbSet<Crew> Crews { get; set; }
}

然后编写测试：

[Test]
public void TestThatCreatingAndReadingCrewWorks()
{
    // 配置内存数据库，每个测试用独立库名避免数据污染
    var dbOptions = new DbContextOptionsBuilder<AppDbContext>()
        .UseInMemoryDatabase(databaseName: "Test_Crew_Database_" + Guid.NewGuid())
        .Options;

    // 使用using确保DbContext被正确释放
    using (var ctx = new AppDbContext(dbOptions))
    {
        // 实例化仓储
        var crewRepo = new CrewRepository(ctx);
        
        // 执行创建操作
        var testCrew = new Crew { Id = 102, Name = "Test Joe" };
        crewRepo.Create(testCrew);
        ctx.SaveChanges();

        // 验证读取结果
        var retrievedCrew = crewRepo.Read(102);
        Assert.That(retrievedCrew.Name, Is.EqualTo("Test Joe"));
    }
}

方法2：手动创建Fake DbContext和DbSet（适合EF6或不想用内存数据库的场景） #

如果你的项目用的是EF6，或者你想完全控制数据行为，可以手动实现Fake版本的DbContext和DbSet，用内存集合模拟数据库表。

步骤1：实现Fake DbSet #

public class FakeDbSet<T> : IDbSet<T> where T : class
{
    private readonly HashSet<T> _inMemoryData = new HashSet<T>();
    private readonly IQueryable _queryableData;

    public FakeDbSet()
    {
        _queryableData = _inMemoryData.AsQueryable();
    }

    // 实现仓储用到的CRUD方法
    public T Add(T item)
    {
        _inMemoryData.Add(item);
        return item;
    }

    public T Find(params object[] keyValues)
    {
        // 针对Crew实体的主键Id实现Find逻辑，其他实体可按需扩展
        if (typeof(T) == typeof(Crew))
        {
            int targetId = (int)keyValues[0];
            return _inMemoryData.OfType<Crew>().FirstOrDefault(c => c.Id == targetId) as T;
        }
        throw new NotImplementedException($"Find方法未实现{typeof(T)}类型的处理");
    }

    // 实现IDbSet<T>和IQueryable的其他必要成员
    public T Remove(T item)
    {
        _inMemoryData.Remove(item);
        return item;
    }

    public IEnumerator<T> GetEnumerator() => _inMemoryData.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    public Type ElementType => _queryableData.ElementType;
    public Expression Expression => _queryableData.Expression;
    public IQueryProvider Provider => _queryableData.Provider;
    // 其他如Attach、Create等方法可根据你的仓储实际使用情况补充
}

步骤2：实现Fake DbContext #

public class FakeAppDbContext : DbContext
{
    public FakeAppDbContext()
    {
        Crews = new FakeDbSet<Crew>();
    }

    public DbSet<Crew> Crews { get; set; }

    // 重写Set方法，返回FakeDbSet实例
    public override DbSet<T> Set<T>() where T : class
    {
        if (typeof(T) == typeof(Crew))
        {
            return Crews as DbSet<T>;
        }
        throw new NotImplementedException($"Set方法未实现{typeof(T)}类型的处理");
    }
}

步骤3：编写测试 #

[Test]
public void TestThatReadCrewWorksWithFakeContext()
{
    // 初始化Fake上下文并添加测试数据
    var fakeCtx = new FakeAppDbContext();
    fakeCtx.Crews.Add(new Crew { Id = 102, Name = "Test Joe" });

    // 实例化仓储和业务逻辑层
    var crewRepo = new CrewRepository(fakeCtx);
    var crewLogic = new CrewLogic(crewRepo); // 注意：逻辑层最好依赖IRepository<Crew>抽象而非具体实现

    // 验证读取操作
    var result = crewLogic.LReadCrew(102);
    Assert.That(result.Name, Is.EqualTo("Test Joe"));
}

方法3：用Moq框架Mock DbContext和DbSet（灵活，适合聚焦特定方法测试） #

如果你只想测试某个特定方法，不想手动写Fake类，可以用Moq框架直接MockDbContext和DbSet，快速模拟数据行为。

示例代码 #

[Test]
public void TestThatReadCrewWorksWithMoq()
{
    // 准备测试数据
    var testCrews = new List<Crew>
    {
        new Crew { Id = 102, Name = "Test Joe" },
        new Crew { Id = 103, Name = "Test Jane" }
    }.AsQueryable();

    // Mock DbSet<Crew>
    var mockDbSet = new Mock<DbSet<Crew>>();
    // 模拟IQueryable行为
    mockDbSet.As<IQueryable<Crew>>().Setup(m => m.Provider).Returns(testCrews.Provider);
    mockDbSet.As<IQueryable<Crew>>().Setup(m => m.Expression).Returns(testCrews.Expression);
    mockDbSet.As<IQueryable<Crew>>().Setup(m => m.ElementType).Returns(testCrews.ElementType);
    mockDbSet.As<IQueryable<Crew>>().Setup(m => m.GetEnumerator()).Returns(testCrews.GetEnumerator());
    // 模拟Find方法
    mockDbSet.Setup(m => m.Find(It.IsAny<object[]>())).Returns((object[] keyValues) =>
        testCrews.FirstOrDefault(c => c.Id == (int)keyValues[0]));

    // Mock DbContext
    var mockCtx = new Mock<DbContext>();
    mockCtx.Setup(m => m.Set<Crew>()).Returns(mockDbSet.Object);

    // 实例化仓储和逻辑层
    var crewRepo = new CrewRepository(mockCtx.Object);
    var crewLogic = new CrewLogic(crewRepo);

    // 验证结果
    var result = crewLogic.LReadCrew(102);
    Assert.That(result.Name, Is.EqualTo("Test Joe"));
}

关键优化建议 #

1. 依赖抽象而非具体实现：你的业务逻辑层（CrewLogic）应该依赖IRepository<Crew>接口，而不是直接实例化CrewRepository。这样测试时可以轻松替换成Mock/Fake仓储，解耦效果更好。比如把逻辑层构造函数改成：

   public CrewLogic(IRepository<Crew> crewRepository)
   {
       _crewRepository = crewRepository;
   }
   

2. 隔离测试数据：每个测试用独立的DbContext实例（比如用using包裹），避免测试之间的数据互相干扰。

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