I start a few parallel tasks, like this:
var tasks =
Enumerable.Range(1, 500)
.Select(i => Task.Factory.StartNew<int>(ProduceSomeMagicIntValue))
.ToArray();
and then join them with
Task.WaitAll(tasks);
On this last line I get a blue squiggly marker under tasks
, with a warning message:
Co-variant array conversion from Task[] to Task[]
can cause run-time exception on write operation.
I understand why I get this message, but is there a way around that? (for example, like a generic version of Task.WaitAll()
?)
WaitAll(Task[], TimeSpan) Waits for all of the provided cancellable Task objects to complete execution within a specified time interval. WaitAll(Task[], Int32, CancellationToken) Waits for all of the provided Task objects to complete execution within a specified number of milliseconds or until the wait is cancelled.
The Task. WaitAll blocks the current thread until all other tasks have completed execution. The Task. WhenAll method is used to create a task that will complete if and only if all the other tasks have completed.
A generic method of Task.WaitAll would imply that all Tasks would have to return the same type which would be extremely limited usefulness. Writting something like that could be done manually (see Bas Brekelmans answer), but this wont allow ContinueWith or cancellation without alot of work.
A simple solution if you aren't using the array for anything else is
.ToArray<Task>();
I'm pretty sure it's a safe operation even with the warning, but if you really wanted to get around it a better option than creating your own implementation would be just to convert your tasks
parameter into the type it wants:
Task.WaitAll(tasks.Cast<Task>().ToArray())
That kills the blue squiggles for me, lets me keep my tasks
variable generic and doesn't force me to create a whole lot of new scary code that's ultimately unnecessary.
Actually there IS a similar generic overload:
Task all = Task.WhenAll(tasks)
This is different in this it returns a Task
that will complete after all tasks completed. so you can use await
on it, or Wait()
, whatever you want.
Look at the signature:
Overloads
--------- NON GENERIC OVERLOADS --------------
WhenAll(IEnumerable<Task>)
Creates a task that will complete when all of theTask
objects in an enumerable collection have completed.
WhenAll(Task[])
Creates a task that will complete when all of theTask
objects in an array have completed.--------- GENERIC OVERLOADS --------------
WhenAll<TResult>(IEnumerable<Task<TResult>>)
Creates a task that will complete when all of theTask<TResult>
objects in an enumerable collection have completed.
WhenAll<TResult>(Task<TResult>[])
Creates a task that will complete when all of theTask<TResult>
objects in an array have completed.
You can create an extension method to do this.
I do not know the exact implementation of WaitAll, but we can assume it waits for every item to complete:
static class TaskExtensions
{
public static void WaitAll<T>(this Task<T>[] tasks)
{
foreach (var item in tasks)
{
item.Wait();
}
}
}
Then call, from your current code:
tasks.WaitAll();
Edit
The actual implementation is a bit more complex. I have omitted the code from this answer because it is fairly long.
http://pastebin.com/u30PmrdS
You can modify this to support generic tasks.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With