private Task <FunctionResult <TResultType> > ExecuteFuncWhenReady <TResultType>(
FunctionRequest <TResultType> funcRequest,
CancellationTokenManager tokenManager,
ProgressManager <TResultType> progressManager)
{
// Wait so we limit the number of concurrent threads.
_semaphore.Wait();
return(Task
.Run(() => ExecuteFunc(funcRequest, tokenManager, progressManager))
.ContinueWith(task => { _semaphore.Release(); return task.Result; }));
}
private static FunctionResult <TResultType> ExecuteFunc <TResultType>(
FunctionRequest <TResultType> funcRequest,
CancellationTokenManager tokenManager,
ProgressManager <TResultType> progressManager)
{
var result = tokenManager.IsCancellationRequested
? Try <TResultType>(new TaskCanceledException())
: funcRequest.Func().Strict();
// On error, signal cancellation of remaining tasks if required.
tokenManager.SetCancelIfError(result);
// Report task completion to caller.
progressManager.Report(result, funcRequest.Idx);
return(new FunctionResult <TResultType>(result, funcRequest.Idx));
}
private Seq <FunctionResult <TResultType> > Execute <TResultType>(
IEnumerable <Func <Try <TResultType> > > funcs,
bool failOnFirstError,
ConcurrentFunctionSettings <TResultType> settings = null)
{
var functionRequests = funcs.Select((func, idx) => new FunctionRequest <TResultType>(func, idx)).ToArray();
var tokenManager = new CancellationTokenManager(settings?.CancellationToken, failOnFirstError);
var progressManager = new ProgressManager <TResultType>(settings?.Progress, functionRequests.Length);
var results = functionRequests
.Select(func => ExecuteFuncWhenReady(func, tokenManager, progressManager))
.ToArray();
// Ensure that we wait until all the running tasks are complete so the
// Semaphore Slim doesn't get disposed before it's finished running and we exit.
Task.WaitAll(results.ToArray <Task>());
return(results.Map(c => c.Result).ToSeq());
}
