Task.Wait in ContinueWhenAll Action

Question

I was working on encorperating threads into my azure code for putting things on a queue. to do this i used http://www.microsoft.com/download/en/details.aspx?id=19222 as a reference.

my code to enqueue multiple messages looks like this:

public void AddMessagesAsync(IEnumerable<IQueueMessage> messages, string queue = null, TimeSpan? timeToLive = null)
{
  //check if we need to switch queues
  if (!String.IsNullOrEmpty(queue))
  {
    SetCurrent(queue);
  }

  //setup list of messages to enqueue
  var tasks = new List<Task>();
  Parallel.ForEach(messages, current => {
    if (timeToLive.HasValue)
    {
      //create task with TPL
      var task = Task.Factory.FromAsync(Current.BeginAddMessage, Current.EndAddMessage, Convert(current), timeToLive.Value, tasks); 
      //setup continuation to trigger eventhandler
      tasks.Add(task.ContinueWith((t) => AddMessageCompleted(t)));
    }
    else
    {
      //create task with TPL
      var task = Task.Factory.FromAsync(Current.BeginAddMessage, Current.EndAddMessage, Convert(current), tasks);
      //setup continuation to trigger eventhandler
      tasks.Add(task.ContinueWith((t) => AddMessageCompleted(t)));
    }
  });

  //setup handler to trigger when all messages are enqueued, a we are blocking the thread over there to wait for all the threads to complete
  Task.Factory.ContinueWhenAll(tasks.ToArray(), (t) => AddMessagesCompleted(t));               
}

private void AddMessagesCompleted(Task[] tasks)
{
  try
  {
    //wait for all tasks to complete
    Task.WaitAll(tasks);
  }
  catch (AggregateException e)
  {
    //log the exception
    var ex = e;
    //return ex;
  }

  if (AddedMessages != null)
  {
    AddedMessages(tasks, EventArgs.Empty);
  }
}

Now my question is about the Task.Wait in the continuation (which is according to the document provided by MS). it seems a bit strange to wait for threads where you already know the have completed right? the only reason i can imagine is to bubble the errors and process those. am i missing something here?

score 4 · Accepted Answer · answered Aug 10 '11 at 08:41

4

Task.WaitAll() will throw an AggregateException when at least one of the Task instances was canceled -or- an exception was thrown during the execution of at least one of the Task instances.

ContinueWhenAll() will not throw this exception and its simply start your last task when everything finishes canceled or not etc.

answered Aug 10 '11 at 08:41

Skomski

4,827
21
30

i guess we agree on my assumption then? – Didier Caron Aug 10 '11 at 09:09
@Didier Yeah - forget that part in my answer :) – Skomski Aug 10 '11 at 09:25

score 2 · Answer 2 · edited Jun 05 '16 at 13:05

2

First, I've noticed you are using List<T> with Parallel.ForEach which is not thread safe, you should replace it with a concurrent collection, eg: ConcurrentQueue<T>.

Regarding WaitAll vs ContinueWhenAll, WaitAll will throw if any of the tasks is faulted, so the code above is to validate all the tasks have completed successfully, you can do the same if you pass ContinuationOptions parameter to ContinueWhenAll like OnlyRanToCompeletion so the continuation task will be scheduled only if all tasks completed successfully.

edited Jun 05 '16 at 13:05

barakcaf

1,294
2
16
27

answered Aug 12 '11 at 08:09

Emad Omara

512
4
3

Hi! thanks for the pointer about the thread safety.. definite lifesaver. – Didier Caron Aug 12 '11 at 13:12

Task.Wait in ContinueWhenAll Action

2 Answers2