C#单元测试：验证Task.WhenAll()中的异步方法是否正确并行执行

你的问题核心在于模拟异步操作的方式不对，导致无法真实复现并行执行的场景。我们来一步步解决这个问题：

为什么你之前的尝试失败了？ #

1. Thread.Sleep(1000)的问题：
   Moq的Callback是同步执行的——当你的GetData方法调用dataServiceA.GetDataTypeA()时，Callback里的Thread.Sleep会阻塞当前测试线程，四个方法的Sleep会顺序执行，总耗时自然是4秒左右，完全体现不出并行。

2. Task.Delay(1000)的问题：
   你在Callback里调用了Task.Delay但没有await，这个延迟任务会被丢到后台但不会阻塞当前执行，所以模拟的方法几乎瞬间完成，总耗时极短，但这根本不是真实的异步延迟场景。

正确的解决方案：模拟真实的异步延迟+验证执行时间重叠 #

要验证并行，最可靠的方式不是只看总耗时（线程调度可能导致总耗时略超预期），而是记录每个子方法的执行时间戳，验证它们的执行时间段是否重叠。

具体测试代码实现 #

[TestMethod]
public async Task GetData_ExecutesSubmethodsInParallel() 
{
    // 记录每个子方法的开始/结束时间
    DateTime aStart, aEnd;
    DateTime bStart, bEnd;
    DateTime cStart, cEnd;
    DateTime dStart, dEnd;

    // 模拟每个服务的异步方法：真实await延迟，同时记录时间
    mockedDataServiceA.Setup(a => a.GetDataTypeA())
        .ReturnsAsync(async () => 
        {
            aStart = DateTime.Now;
            await Task.Delay(1000); // 真实模拟异步IO延迟
            aEnd = DateTime.Now;
            return mockedDataA;
        });

    mockedDataServiceB.Setup(b => b.GetDataTypeB())
        .ReturnsAsync(async () => 
        {
            bStart = DateTime.Now;
            await Task.Delay(1000);
            bEnd = DateTime.Now;
            return mockedDataB;
        });

    mockedDataServiceC.Setup(c => c.GetDataTypeC())
        .ReturnsAsync(async () => 
        {
            cStart = DateTime.Now;
            await Task.Delay(1000);
            cEnd = DateTime.Now;
            return mockedDataC;
        });

    mockedDataServiceD.Setup(d => d.GetDataTypeD())
        .ReturnsAsync(async () => 
        {
            dStart = DateTime.Now;
            await Task.Delay(1000);
            dEnd = DateTime.Now;
            return mockedDataD;
        });

    // 执行待测试方法
    var dataService = new DataService(
        mockedDataServiceA.Object, 
        mockedDataServiceB.Object, 
        mockedDataServiceC.Object, 
        mockedDataServiceD.Object);
    
    var startTime = DateTime.Now;
    var result = await dataService.GetData();
    var totalDuration = DateTime.Now.Subtract(startTime);

    // 验证1：总耗时应该接近1秒（允许少量线程调度误差）
    Assert.IsTrue(totalDuration.TotalSeconds < 2, "总耗时过长，可能未并行执行");

    // 验证2：四个方法的执行时间段必须有重叠（核心验证逻辑）
    // 比如，验证A的执行期间，其他方法已经开始执行
    Assert.IsTrue(aStart < bEnd && bStart < aEnd, "A和B未并行执行");
    Assert.IsTrue(aStart < cEnd && cStart < aEnd, "A和C未并行执行");
    Assert.IsTrue(aStart < dEnd && dStart < aEnd, "A和D未并行执行");
    // 可以根据需要添加更多交叉验证，确保所有任务都有时间重叠
}

关键细节说明 #

• 用ReturnsAsync(Func<Task<T>>)替代Callback：这种方式允许你在模拟方法中编写真实的异步逻辑，await Task.Delay会正确模拟异步操作的延迟，而不会阻塞测试线程。
• 时间重叠验证更可靠：总耗时的断言容易受系统线程调度影响（比如偶尔可能到1.2秒），但时间重叠的验证能直接证明多个任务是同时在执行的，而非顺序执行。
• 真实场景的还原：这种模拟方式和你生产环境中异步IO操作（比如数据库查询、API调用）的行为一致，能有效验证Task.WhenAll的并行逻辑是否正常工作。

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