Task.WhenAll¹ can run a list of tasks concurrently, but this could potentially exhaust the underlying resource (e.g. db connections). Instead we can run the tasks in batches, limiting the size or concurrency of each batch to something the underlying resource can handle.

Using SemaphoreSlim

The following implementation is a simplification of a StackOverflow answer². It uses a SemaphoreSlim³, which is a lightweight alternative⁴ to Semaphore⁵.

public static async Task<IEnumerable<T>> WhenAllBatched<T>(IEnumerable<Task<T>> tasks, int batchSize)
{
    using var semaphore = new SemaphoreSlim(batchSize);

    var pendingTasks = tasks.Select(async task =>
    {
        try
        {
            semaphore.Wait();
            return await task;
        }
        finally
        {
            semaphore.Release();
        }
    });

    return await Task.WhenAll(pendingTasks);
}

Using a loop

An even cheaper alternative, would be to use Chunk⁶ to create a list of batches, then loop over those batches, running each concurrently with Task.WhenAll¹.

public static async Task<IEnumerable<T>> WhenAllBatched<T>(IEnumerable<Task<T>> tasks, int batchSize)
{
    IEnumerable<T> results = new List<T>();
    foreach (var batch in tasks.Chunk(batchSize))
    {
        var partialResults = await Task.WhenAll(batch);
        results = results.Concat(partialResults);
    }
    return results;
}