/// <summary> /// The given Action will be performed when the task ends. /// </summary> /// <param name="action">The action to perform.</param> /// <param name="target">The DispatcherBase to perform the action on.</param> /// <returns>This task.</returns> public static Task <T> WhenEnded <T>(this Task <T> task, Action <Task <T> > action, DispatcherBase target) { task.TaskEnded += t => { if (target == null) { action(task); } else { target.Dispatch(() => action(task)); } }; return(task); }
/// <summary> /// Starts this Task when the other Task ended successfully. /// </summary> /// <param name="followingTask">The task to await.</param> /// <param name="target">The DispatcherBase to start this task on.</param> /// <returns>This task.</returns> public static Task Await(this Task that, Task taskToWaitFor, DispatcherBase target) { taskToWaitFor.Then(that, target); return(that); }
/// <summary> /// The given Action will be performed when the task fails. /// </summary> /// <param name="action">The action to perform.</param> /// <param name="target">The DispatcherBase to perform the action on.</param> /// <returns>This task.</returns> public static Task <T> WhenFailed <T>(this Task <T> task, Action <Task <T> > action, DispatcherBase target) { return(task.WhenEnded <T>(t => { if (t.IsFailed) { action(t); } }, target)); }
/// <summary> /// Starts the given Task when the tasks ended successfully. /// </summary> /// <param name="followingTask">The task to start.</param> /// <param name="target">The DispatcherBase to start the following task on.</param> /// <returns>The tasks.</returns> public static IEnumerable <Task> Then(this IEnumerable <Task> that, Task followingTask, DispatcherBase target) { var remaining = that.Count(); var syncRoot = new object(); foreach (var task in that) { task.WhenFailed(() => { if (followingTask.ShouldAbort) { return; } followingTask.Abort(); }); task.WhenSucceeded(() => { if (followingTask.ShouldAbort) { return; } lock (syncRoot) { remaining--; if (remaining == 0) { if (target != null) { followingTask.Run(target); } else if (ThreadBase.CurrentThread is TaskWorker) { followingTask.Run(((TaskWorker)ThreadBase.CurrentThread).TaskDistributor); } else { followingTask.Run(); } } } }); } return(that); }
/// <summary> /// The given Action will be performed when the task succeeds. /// </summary> /// <param name="action">The action to perform.</param> /// <param name="target">The DispatcherBase to perform the action on.</param> /// <returns>This task.</returns> public static Task <T> WhenSucceeded <T>(this Task <T> task, Action <Task <T> > action, DispatcherBase target) { Action <Task <T> > perform = t => { if (target == null) { action(t); } else { target.Dispatch(() => { if (t.IsSucceeded) { action(t); } }); } }; return(task.WhenEnded <T>(t => { if (t.IsSucceeded) { perform(t); } }, null)); }
/// <summary> /// Invokes the given action with the set result of the task when the task succeeded. /// </summary> /// <param name="action">The action to perform.</param> /// <param name="target">The DispatcherBase to perform the action on.</param> /// <returns>This task.</returns> public static Task <T> OnResult <T>(this Task <T> task, Action <T> action, DispatcherBase actionTarget) { return(task.WhenSucceeded <T>(t => action(t.Result), actionTarget)); }
/// <summary> /// Invokes the given action with the set result of the task when the task succeeded. /// </summary> /// <param name="action">The action to perform.</param> /// <param name="target">The DispatcherBase to perform the action on.</param> /// <returns>This task.</returns> public static Task OnResult <T>(this Task task, Action <T> action, DispatcherBase target) { return(task.WhenSucceeded(t => action((T)t.RawResult), target)); }
/// <summary> /// Starts the given Action when one task has not successfully ended /// </summary> /// <param name="action">The action to start.</param> /// <param name="target">The DispatcherBase to start the following action on.</param> /// <returns>The tasks.</returns> public static IEnumerable <Task> WhenFailed(this IEnumerable <Task> that, Action action, DispatcherBase target) { var hasFailed = false; var syncRoot = new object(); foreach (var task in that) { task.WhenFailed(() => { lock (syncRoot) { if (hasFailed) { return; } hasFailed = true; if (target == null) { action(); } else { target.Dispatch(() => { action(); }); } } }); } return(that); }
/// <summary> /// Starts the given Action when all Tasks ended successfully. /// </summary> /// <param name="action">The action to start.</param> /// <param name="target">The DispatcherBase to start the following action on.</param> /// <returns>The tasks.</returns> public static IEnumerable <Task> WhenSucceeded(this IEnumerable <Task> that, Action action, DispatcherBase target) { var remaining = that.Count(); var syncRoot = new object(); foreach (var task in that) { task.WhenSucceeded(() => { lock (syncRoot) { remaining--; if (remaining == 0) { if (target == null) { action(); } else { target.Dispatch(() => { action(); }); } } } }); } return(that); }