/// <summary>
/// Executes all child tasks in parallel. If any child task fails, all child tasks
/// that are still running will be terminated prematurely.
/// </summary>
/// <returns>Success if all child tasks run successfully, the result code of the
/// first child task to fail if any fail, or interrupted if execution is terminated
/// prematurely.</returns>
public override TaskResultCode Execute()
{
int taskCount = ChildTasks.Count;
_taskResults = new List <TaskResult>(taskCount);
foreach (ITask task in ChildTasks)
{
AsyncTaskExecute execute = new AsyncTaskExecute(task.Execute);
IAsyncResult result = execute.BeginInvoke(null, null);
_taskResults.Add(new TaskResult()
{
Task = task,
Execute = execute,
Result = result
});
}
TaskResultCode resultCode = TaskResultCode.Success;
bool isDone = false;
while (!ShouldTerminate && !isDone)
{
int completedCount = 0;
foreach (TaskResult taskResult in _taskResults)
{
if (taskResult.Result.IsCompleted == true)
{
++completedCount;
resultCode = taskResult.Execute.EndInvoke(taskResult.Result);
}
if (resultCode != TaskResultCode.Success)
{
Terminate();
break;
}
}
if (completedCount == taskCount)
{
isDone = true;
}
}
if (ShouldTerminate)
{
return(TaskResultCode.Interrupted);
}
else
{
return(resultCode);
}
}
/// <summary>
/// Executes each child task in order until all succeed or one fails.
/// </summary>
/// <returns>Success if all child task succeeds, or the result code of the
/// first child task that is not successful.</returns>
public override TaskResultCode Execute()
{
foreach (ITask task in ChildTasks)
{
TaskResultCode resultCode = task.Execute();
if (resultCode != TaskResultCode.Success)
{
return(resultCode);
}
}
return(TaskResultCode.Success);
}
/// <summary>
/// Executes the wrapped task <see cref="RunCount"/> number of times or until
/// failure, whichever occurs first.
/// </summary>
/// <returns>Success if the wrapped task was run the set number of times without failure,
/// or the result code of the last iteration if not successful.</returns>
public override TaskResultCode Execute()
{
int count = 0;
TaskResultCode result = TaskResultCode.Success;
while ((count < RunCount) && (result == TaskResultCode.Success))
{
result = ChildTask.Execute();
++count;
}
return(result);
}
/// <summary>
/// Executes the wrapped task, returning the inverse of the tasks result code.
/// </summary>
/// <returns>Success if the wrapped task returned a non-successful result code,
/// or failure if it returned success.</returns>
public override TaskResultCode Execute()
{
TaskResultCode result = ChildTask.Execute();
return((result == TaskResultCode.Success) ? TaskResultCode.Failure : TaskResultCode.Success);
}
