Simultaneous downloads limit

I'm making asynchronous requests with WebRequest.BeginGetResponse to download files from a server. All works nice but I want to download no more of 5 files at the same time. In Java I would use a fixed thread pool but I don't know how to do the same in C#. Any ideas?

class HttpFetcher
{
    public void MakeRequest(Uri uri)
    {
        WebRequest request = WebRequest.Create(uri);
        request.Proxy = null;
        RequestState requestState = new RequestState();
        requestState.Request = request;
        IAsyncResult result = (IAsyncResult) request.BeginGetResponse(new AsyncCallback(ResponseCallback), requestState);

        ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(TimeOutCallback), request, 1000, true);
    }

    private void ResponseCallback(IAsyncResult result)
    {
        try
        {
            RequestState requestState = (RequestState)result.AsyncState;
            WebRequest request = requestState.Request;
            requestState.Response = request.EndGetResponse(result);
            Stream responseStream = requestState.Response.GetResponseStream();
            requestState.ResponseStream = responseStream;
            IAsyncResult asynchronousResultRead = responseStream.BeginRead(requestState.BufferRead, 0, 1024, new AsyncCallback(ReadCallback), requestState);
        }
        catch (Exception ex)
        {
            Console.WriteLine("Exception raised!");
            Console.WriteLine("Message : {0}", ex.Message);
            RequestState state = (RequestState)result.AsyncState;
            if (state.Response != null)
                state.Response.Close();
        }

    }

    private void ReadCallback(IAsyncResult result)
    {
        try
        {
            RequestState requestState = (RequestState)result.AsyncState;
            Stream responseStream = requestState.ResponseStream;

            int bytesRead = responseStream.EndRead(result);
            if (bytesRead > 0)
            {
                requestState.RequestData.Append(Encoding.ASCII.GetString(requestState.BufferRead, 0, bytesRead));
                IAsyncResult asynchronousResult = responseStream.BeginRead(requestState.BufferRead, 0, 1024, new AsyncCallback(ReadCallback), requestState);
            }
            else
            {
                Console.WriteLine("\nThe HTML page Contents are:  ");
                if (requestState.RequestData.Length > 1)
                {
                    string sringContent;
                    sringContent = requestState.RequestData.ToString();
                    //Console.WriteLine(sringContent);
                }
                Console.WriteLine("\nPress 'Enter' key to continue........");
                responseStream.Close();
            }
        }
        catch (WebException e)
        {
            Console.WriteLine("WebException raised!");
            Console.WriteLine("\n{0}", e.Message);
            Console.WriteLine("\n{0}", e.Status);
        }
        catch (Exception e)
        {
            Console.WriteLine("Exception raised!");
            Console.WriteLine("Source : {0}", e.Source);
            Console.WriteLine("Message : {0}", e.Message);
        }
    }

    private void TimeOutCallback(object state, bool timedOut)
    {
        if (timedOut)
        {
            WebRequest request = (WebRequest)state;
            if (state != null)
            {
                request开发者_运维百科.Abort();
            }
        }
    }
}

---

You could use Task.Factory.FromAsync() and use a Task Scheduler that limits the Degree of Concurrency

Without diving into FromAsync() here a very simplified example that shows that at most 5 tasks are running in parallel, regardless how many are queued:

public static void Main()
{
    var scheduler = new LimitedConcurrencyLevelTaskScheduler(5);
    TaskFactory factory = new TaskFactory(scheduler);

    for (int i = 0; i < 50; i++)
    {
        int idx = i;
        var newTask = factory.StartNew(() =>
            {
                Console.WriteLine("Starting " + idx);
                Thread.Sleep(5000);
            });
    }
    Console.ReadLine();
}