如何从List.ForEach C＃进行异步调用

Question

I have list of items and for each item i want to call the UploadChunkToServer method but in parallel. There will always be only 4 items in the list.

if (DataQueue.Count == NumberofChunksToRead)
{
    DataQueue.ToList().ForEach(Chunk =>
    {
        UploadChunkToServer(Chunk);
    });
}

Above is my code call in the method and the method signature is as follows.

private void UploadChunkToServer(UserCustomFile Chunk)
{
    var client = new RestClient(Helper.GetServerURL());

    var request = new RestRequest("api/fileupload/savechunk", Method.POST);
    request.AddHeader("Content-type", "application/json");
    request.RequestFormat = RestSharp.DataFormat.Json;
    request.AddJsonBody(Chunk);

    client.ExecuteAsync(request, response =>
    {
        if (response.StatusCode != System.Net.HttpStatusCode.OK)
        {
            throw new Exception(response.ErrorMessage);
        }
        else
        {
            ChunkStatuses.Add(Chunk.ChunkID);
        }
    });
}

I have tried to add the async operator but no luck. Any ideas how this could be accomplished?

Answer 1

Perhaps you can make use of Parallel and ForEach in specific:

Parallel.ForEach(DataQueue.ToList(), Chunk =>
                 {
                      UploadChunkToServer(Chunk);
                 });

Answer 2

You could do the following:

var tasks = new List<Task<bool>>();

DataQueue.ToList().ForEach(chunk =>
{
      tasks.Add(Task.Run(() => UploadChunkToServer(chunk)));
});

await tasks.WhenAll();

But you should change UploadChunkToServer to return something; a bool indicating if the upload was succesful. void Tasks should be avoided, pun intended...

UPDATE: As TheBoyan's answer points out, you can simplify this making UploadChunkToServer async, but I'd still recommend returning something so you can get a hold on the tasks for later processing. If its a fire and forget scenario, this wouldn't be necessary:

var tasks = new List<Task<bool>>();

DataQueue.ToList().ForEach(chunk =>
{
    tasks.Add(UploadChunkToServer(chunk));
});

await tasks.WhenAll();

And UploadChunkToServer would look like:

private async Task<bool> UploadChunkToServer(UserCustomFile Chunk)
{
    var client = new RestClient(Helper.GetServerURL());

    var request = new RestRequest("api/fileupload/savechunk", Method.POST);
    request.AddHeader("Content-type", "application/json");
    request.RequestFormat = RestSharp.DataFormat.Json;
    request.AddJsonBody(Chunk);

    return await client.ExecuteAsync(request, response =>
    {
        if (response.StatusCode != System.Net.HttpStatusCode.OK)
        {
            throw new Exception(response.ErrorMessage);
        }
        else
        {
            ChunkStatuses.Add(Chunk.ChunkID);
            return true;
        }
    });
}

Answer 3

Your question is a little unclear, and I think you have mixed up asynchronous and parallel, which are not necessarily the same in C#.

There is two types of asynchrony in C#:

• I/O bound (read/write over network etc.)

• Long running (high processing etc.)

Yours is a I/O bound operation, so it works by notifying the caller when it's done(by providing a state machine in the background). Think of it as an event based pattern.

The way you deal with it best is await if you already have an [YourMethodName]Async method provided by an API or a library, or TaskCompletionSource to implement it yourself. Note that you don't necessarily need a parallel thread to implement it(by running Task.Run or some other way), the framework (or the one that implemented the method did it for you in the case of [YourMethodName]Async) provides a Task when it's done for you already.

So, if you want to make your method run client.ExecuteAsync asynchronously assuming ExecuteAsync returns a Task . In your code you can do like this:

// add async keyword to notify that you are awaitng int he method
// perhaps also change the void to Task
private async Task UploadChunkToServer(UserCustomFile Chunk)
{
    var client = new RestClient(Helper.GetServerURL());

    var request = new RestRequest("api/fileupload/savechunk", Method.POST);
    request.AddHeader("Content-type", "application/json");
    request.RequestFormat = RestSharp.DataFormat.Json;
    request.AddJsonBody(Chunk);

    //add await operator to make this part run acync
    return await client.ExecuteAsync(request, response =>
    {
        if (response.StatusCode != System.Net.HttpStatusCode.OK)
        {
            throw new Exception(response.ErrorMessage);
        }
        else
        {
            ChunkStatuses.Add(Chunk.ChunkID);
        }
    });
}

then further up in your call stack:

  if (DataQueue.Count == NumberofChunksToRead)
  {
       DataQueue.ToList().ForEach(Chunk =>
       {
           await UploadChunkToServer(Chunk);
       });
  }

You also might want to consider returning a result with Task, so that you can follow the progress or see which ones have already been uploaded etc.

If you want to run the method in parallel , the previous answer with Parallel Foreach will do the job. Although, I think it's not good to do that in this case since you have an I/O bound operation. What you basically would be doing is running a long running task that does nothing but wait most of the time. In the case of a 4 core processor and with you spawning 4 threads that would mean you occupy all of them by just waiting. Something that you are already been doing with await in the first place.

Answer 4

You can't do it because the paramter to ForEach is a diffrent function called by ForEach and not part of your fuction that is async - BUT - the actual solution is to not use ForEach - foreach is actually a bit shorter and doesn't have this problem

if (DataQueue.Count == NumberofChunksToRead)
{
    forach(var Chunk in DataQueue.ToList())
    {
        await UploadChunkToServer(Chunk);
    }
}