Menu
I've got a bit of code that is acting as a light weight, non-blocking, critical section. I am hoping that no matter what happens with _func and cancellationToken in the Task.Run clause, that the continuation is guaranteed to run such that the Exit statement in its finally block will always execute.
Is it safe to assume that the finally block below, short of catastrophic failure in the process, will be executed with roughly the same guarantees that finally normal operates with?
if (Enter())
{
Task.Run<T>(_func, cancellationToken)
.ContinueWith((antecedent) =>
{
try
{
antecedent.Wait(cancellationToken);
Interlocked.Exchange<T>(ref _result, antecedent.Result);
}
catch (AggregateException e)
{
Interlocked.Exchange(ref _exceptions, e);
}
catch (OperationCanceledException)
{
ResetState();
}
catch (Exception e)
{
Interlocked.Exchange(ref _exceptions, new AggregateException(e));
}
finally
{
Exit();
}
})
}
341
ContinueWith(Action<Task,Object>, Object, TaskScheduler)Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. The continuation uses a specified scheduler.
Calling ContinueWith allocates another task per operation (it wraps your delegate in a task object) instead of re-using the state machine instance as the continuation. So you're static callback is then wrapped in a ContinuationTask object.
A continuation task (also known just as a continuation) is an asynchronous task that's invoked by another task, known as the antecedent, when the antecedent finishes.
c# - Run sequence of tasks, one after the other - Stack Overflow. Stack Overflow for Teams – Start collaborating and sharing organizational knowledge.
ContinueWith The ContinueWith function is a method available on the task that allows executing code after the task has finished execution. In simple words it allows continuation. Things to note here is that ContinueWith also returns one Task. That means you can attach ContinueWith one task returned by this method.
public System.Threading.Tasks. Task ContinueWith ( Action<System.Threading.Tasks.Task, object > continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler); An action to run when the Task completes. When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.
If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled. Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes. public System.Threading.Tasks.
ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.
Based on the MSDN documentation:
The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.
So, unless _func never returns (runs in an infinite loop for example), then the continuation will always run.
And when the continuation runs, the finally block is guaranteed to execute as per the rules of C#.
So the answer is yes (unless of course _func never returns).
70
If the token is canceled before the first task runs, the continuation will not run, and thus the finally will not execute. Tested here with VS 2015: http://pastebin.com/9qmUYnqv
Incidentally, there are some design issues with the code as written -- having tasks modify state is not the best idea; the tasks should return values and whatnot. In this particular case, for a nonblocking critical sections, consider using SemaphoreSlim.
2
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
