使用 Task.WhenAll 一次向我的 WebAPI 发送多个请求

Question

我试图（几乎）一次向我的 WebAPI 发送多个相同的请求以进行一些性能测试。 为此，我多次致电PerformRequest 并使用await Task.WhenAll 等待他们。

我想计算完成每个请求所需的时间加上每个请求的开始时间。但是，在我的代码中，我不知道如果 R3（请求号 3）的结果出现在 R1 之前会发生什么？时长会出错吗？

从我在结果中看到的，我认为结果是相互混合的。例如，R4 的结果集为 R1 的结果。所以任何帮助将不胜感激。

GlobalStopWatcher 是一个静态类，我用它来查找每个请求的开始时间。

基本上我想确保每个请求的elapsedMilliseconds 和Duration 都与请求本身相关联。 因此，如果第 10 次请求的结果在第 1 次请求的结果之前，则持续时间将为duration = elapsedTime(10th)-(startTime(1st))。不是这样吗？

我想添加一个lock，但似乎不可能在有await 关键字的地方添加它。

 public async Task<RequestResult> PerformRequest(RequestPayload requestPayload)
    {
        var url = "myUrl.com";

        var client = new RestClient(url) { Timeout = -1 };

        var request = new RestRequest { Method = Method.POST };

        request.AddHeaders(requestPayload.Headers);
        foreach (var cookie in requestPayload.Cookies)
        {
            request.AddCookie(cookie.Key, cookie.Value);
        }
        request.AddJsonBody(requestPayload.BodyRequest);

        var st = new Stopwatch();
        st.Start();
        var elapsedMilliseconds = GlobalStopWatcher.Stopwatch.ElapsedMilliseconds;
        var result = await client.ExecuteAsync(request).ConfigureAwait(false);
        st.Stop();
        var duration = st.ElapsedMilliseconds;

        return new RequestResult() 
        { 
           Millisecond = elapsedMilliseconds,
           Content = result.Content,
           Duration = duration
        };
     }



public async Task RunAllTasks(int numberOfRequests)
{
    GlobalStopWatcher.Stopwatch.Start();

    var arrTasks = new Task<RequestResult>[numberOfRequests];
    for (var i = 0; i < numberOfRequests; i++)
    {
         arrTasks[i] = _requestService.PerformRequest(requestPayload, false);
    }

    var results = await Task.WhenAll(arrTasks).ConfigureAwait(false);

    RequestsFinished?.Invoke(this, results.ToList());
}

Answer 1

我认为你会出错的地方是尝试使用静态 GlobalStopWatcher，然后将此代码推送到你正在测试的函数中。

您应该将所有内容分开，并为每个 RunAllTasks 调用使用一个新的 Stopwatch 实例。

让我们这样吧。

从这些开始：

public async Task<RequestResult<R>> ExecuteAsync<R>(Stopwatch global, Func<Task<R>> process)
{
    var s = global.ElapsedMilliseconds;
    var c = await process();
    var d = global.ElapsedMilliseconds - s;
    return new RequestResult<R>()
    {
        Content = c,
        Millisecond = s,
        Duration = d
    };
}

public class RequestResult<R>
{
    public R Content;
    public long Millisecond;
    public long Duration;
}

现在您可以测试任何符合Func<Task<R>> 签名的内容。

让我们试试这个：

public async Task<int> DummyAsync(int x)
{
    await Task.Delay(TimeSpan.FromSeconds(x % 3));
    return x;
}

我们可以这样设置测试：

public async Task<RequestResult<int>[]> RunAllTasks(int numberOfRequests)
{
    var sw = Stopwatch.StartNew();
    var tasks = 
        from i in Enumerable.Range(0, numberOfRequests)
        select ExecuteAsync<int>(sw, () => DummyAsync(i));
    return await Task.WhenAll(tasks).ConfigureAwait(false);
}

请注意，var sw = Stopwatch.StartNew(); 行会为每个 RunAllTasks 调用捕获一个新的 Stopwatch。没有什么是真正的“全球性”了。

如果我使用RunAllTasks(7) 执行该操作，那么我会得到以下结果：

它运行并且计数正确。

现在你可以重构你的 PerformRequest 方法来做它需要做的事情：

public async Task<string> PerformRequest(RequestPayload requestPayload)
{
    var url = "myUrl.com";
    var client = new RestClient(url) { Timeout = -1 };
    var request = new RestRequest { Method = Method.POST };
    request.AddHeaders(requestPayload.Headers);
    foreach (var cookie in requestPayload.Cookies)
    {
        request.AddCookie(cookie.Key, cookie.Value);
    }
    request.AddJsonBody(requestPayload.BodyRequest);
    var response = await client.ExecuteAsync(request);
    return response.Content;
}

运行测试很容易：

public async Task<RequestResult<string>[]> RunAllTasks(int numberOfRequests)
{
    var sw = Stopwatch.StartNew();
    var tasks = 
        from i in Enumerable.Range(0, numberOfRequests)
        select ExecuteAsync<string>(sw, () => _requestService.PerformRequest(requestPayload));
    return await Task.WhenAll(tasks).ConfigureAwait(false);
}

---

如果对Stopwatch 的线程安全性有任何疑问，那么您可以这样做：

public async Task<RequestResult<R>> ExecuteAsync<R>(Func<long> getMilliseconds, Func<Task<R>> process)
{
    var s = getMilliseconds();
    var c = await process();
    var d = getMilliseconds() - s;
    return new RequestResult<R>()
    {
        Content = c,
        Millisecond = s,
        Duration = d
    };
}

public async Task<RequestResult<int>[]> RunAllTasks(int numberOfRequests)
{
    var sw = Stopwatch.StartNew();
    var tasks = 
        from i in Enumerable.Range(0, numberOfRequests)
        select ExecuteAsync<int>(() => { lock (sw) { return sw.ElapsedMilliseconds; } }, () => DummyAsync(i));
    return await Task.WhenAll(tasks).ConfigureAwait(false);
}