如何为 Parallel.ForEachAsync 设置最小并行度

Question

Let's say I have the following C# code that sends get requests for some array of urls in parallel:

    internal class Program
    {
        static async Task Main(string[] args)
        {
            string[] urls = { "https://example1.com", "https://example2.com", "https://example3.com", "https://example4.com", "https://example5.com" };
            HttpClientHandler clientHandler = new HttpClientHandler();
            using (var client = new HttpClient(clientHandler))
            {
                client.Timeout = TimeSpan.FromSeconds(10);
                var options = new ParallelOptions { MaxDegreeOfParallelism = urls.Length };
                await Parallel.ForEachAsync(urls, options, async (url, stoppingToken) =>
                {
                    try
                    {
                        Console.WriteLine("Processing " + url);
                        HttpResponseMessage response = await client.GetAsync(url);
                        response.EnsureSuccessStatusCode();
                        var resp = await response.Content.ReadAsStringAsync();
                        Console.WriteLine("Response for " + url + " " + resp);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Response for " + url + " " + ex.Message);
                    }
                });
                Console.WriteLine("Completed");
            }
            Console.ReadLine();
        }
    }

If I set the MaxDegreeOfParallelism to the size of the array, does this also act as an implied minimum degree of parallelism? Meaning, would my code attempt to spawn the same number of threads as the MaxDegreeOfParallelism value?

EDIT 1

If not, could I achieve something similar with the below code:

    internal class Program
    {
        public async Task sendRequest(string url)
        {
            HttpClientHandler clientHandler = new HttpClientHandler();
            using (var client = new HttpClient(clientHandler))
            {
                client.Timeout = TimeSpan.FromSeconds(10);
                try
                {
                    Console.WriteLine("Processing " + url);
                    HttpResponseMessage response = await client.GetAsync(url);
                    response.EnsureSuccessStatusCode();
                    var resp = await response.Content.ReadAsStringAsync();
                    Console.WriteLine("Response for " + url + " " + resp);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Response for " + url + " " + ex.Message);
                }
            }
        }
        static async Task Main(string[] args)
        {
            string[] urls = { "https://example1.com", "https://example2.com", "https://example3.com", "https://example4.com", "https://example5.com" };
            foreach (string url in urls)
            {
                Program program = new Program();
                //dont await the sendRequest() method so that you can go through whole loop
                Thread operation = new Thread(() => program.sendRequest(url));
                operation.Start();
            }
            Console.ReadLine();
        }
    }

Answer 1

MaxDegreeOfParallelism to the size of the array, does this also act as an implied minimum degree of parallelism?

No. There is no "minimum degree of parallelism", since the code should still run even on a single core CPU.

would my code attempt to spawn the same number of threads as the MaxDegreeOfParallelism value?

No, it is allowed to use as many threads as MaxDegreeOfParallelism , but does not have to. Using more threads than logical CPU cores would be inefficient for compute bound workloads, so it will try to keep the number as threads as small as possible while still using as much CPU as possible, but I'm not sure about the exact details. Unless you have some reason to do otherwise I would suggest just not setting MaxDegreeOfParallelism and let the loop use its default behavior.

Note that the main benefit of parallel loops are when running compute bound code. Your example seem to be strictly IO bound, so will probably not gain much benefit over using something like this:

await Task.WhenAll(urls.Select(async url => {...}));

This will start all requests sequentially , let the requests run concurrently , and then process the result sequentially again.