private ActionTask GetTask(TaskAffinity affinity, int id, Action <int> body) { return(new ActionTask(Token, _ => body(id)) { Affinity = affinity }); }
protected ActionTask GetTask(ITaskManager taskManager, TaskAffinity affinity, int id, Action <int> body) { return(new ActionTask(taskManager, _ => body(id)) { Affinity = affinity }); }
private ActionTask GetTask(TaskAffinity affinity, int id, Action <int> body, ActionTask dependsOn = null) { return(new ActionTask(Token, _ => body(id), dependsOn) { Affinity = affinity }); }
public static ITask Then(this ITask task, Action <bool> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { Guard.ArgumentNotNull(continuation, "continuation"); return(task.Then(new ActionTask(task.Token, continuation) { Affinity = affinity, Name = "Then" }, runOptions)); }
/// <summary> /// Run a callback at the end of the task execution, on a separate thread, regardless of execution state /// </summary> public ITask Finally(Action <bool, Exception> actionToContinueWith, TaskAffinity affinity = TaskAffinity.Concurrent) { Guard.ArgumentNotNull(actionToContinueWith, nameof(actionToContinueWith)); return(Finally(new ActionTask(Token, actionToContinueWith) { Affinity = affinity, Name = "Finally" })); }
public static ITask Then(this ITask task, Action <bool> continuation, TaskAffinity affinity, bool always = false) { Guard.ArgumentNotNull(continuation, "continuation"); return(task.Then(new ActionTask(task.Token, continuation) { Affinity = affinity, Name = "Then" }, always)); }
public static ITask <T> Then <T>(this ITask task, Task <T> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { var cont = new TPLTask <T>(continuation) { Affinity = affinity, Name = $"ThenAsync<{typeof(T)}>" }; return(task.Then(cont, runOptions)); }
public static ITask <T> Then <T>(this ITask task, Func <T> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, string name = null, TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { task.EnsureNotNull(nameof(task)); continuation.EnsureNotNull(nameof(continuation)); return(task.Then(new FuncTask <T>(task.TaskManager, continuation, token: task.Token) { Affinity = affinity, Name = name ?? $"ThenFunc<{typeof(T)}>" }, runOptions)); }
public static ITask With(this ITaskManager taskManager, Action continuation, TaskAffinity affinity = TaskAffinity.Concurrent, string name = "With") { taskManager.EnsureNotNull(nameof(taskManager)); continuation.EnsureNotNull(nameof(continuation)); return(new ActionTask(taskManager, continuation) { Affinity = affinity, Name = name }); }
public static ITask <T> Then <T>(this ITask task, Task <T> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, bool always = false) { var cont = new FuncTask <T>(continuation) { Affinity = affinity, Name = $"ThenAsync<{typeof(T)}>" }; return(task.Then(cont, always)); }
public static ITask Then(this ITask task, Action continuation, TaskAffinity affinity = TaskAffinity.Concurrent, string name = "Then", TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { task.EnsureNotNull(nameof(task)); continuation.EnsureNotNull(nameof(continuation)); return(task.Then(new ActionTask(task.TaskManager, continuation, token: task.Token) { Affinity = affinity, Name = name }, runOptions)); }
public static ITask ThenAsync(this ITask task, Func <Task> asyncDelegate, TaskAffinity affinity = TaskAffinity.Concurrent, string name = "ThenAsync", TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { task.EnsureNotNull(nameof(task)); asyncDelegate.EnsureNotNull(nameof(asyncDelegate)); var cont = new TPLTask(task.TaskManager, asyncDelegate, token: task.Token) { Affinity = affinity, Name = name }; return(task.Then(cont, runOptions)); }
public ITask Finally(Action <bool, Exception> continuation, TaskAffinity affinity = TaskAffinity.Concurrent) { Guard.ArgumentNotNull(continuation, "continuation"); var ret = new ActionTask(Token, continuation, this, true) { Affinity = affinity, Name = "Finally" }; DependsOn?.SetFaultHandler(ret); ret.ContinuationIsFinally = true; return(ret); }
public ITask Finally(Action <bool, Exception> actionToContinueWith, TaskAffinity affinity = TaskAffinity.Concurrent) { Guard.ArgumentNotNull(actionToContinueWith, nameof(actionToContinueWith)); var ret = Then(new ActionTask(Token, actionToContinueWith) { Affinity = affinity, Name = "Finally" }, true); DependsOn?.SetFaultHandler(ret); ret.ContinuationIsFinally = true; return(ret); }
public static TaskScheduler GetScheduler(TaskAffinity affinity) { switch (affinity) { case TaskAffinity.Exclusive: return(Instance.ExclusiveScheduler); case TaskAffinity.UI: return(Instance.UIScheduler); case TaskAffinity.Concurrent: default: return(Instance.ConcurrentScheduler); } }
public ITask Defer <T>(Func <T, Task> continueWith, TaskAffinity affinity = TaskAffinity.Concurrent, bool always = false) { Guard.ArgumentNotNull(continueWith, "continueWith"); var ret = Then(new StubTask <T>(Token, (s, d) => {}) { Affinity = affinity }); SetDeferred(new DeferredContinuation { Always = always, GetContinueWith = d => new ActionTask <T>(continueWith((T)d)) { Affinity = affinity, Name = "Deferred" } }); return(ret); }
/// <summary> /// Run a callback at the end of the task execution, on a separate thread, regardless of execution state /// </summary> public ITask Finally(Action <bool, Exception> actionToContinueWith, TaskAffinity affinity = TaskAffinity.Concurrent) { Guard.ArgumentNotNull(actionToContinueWith, nameof(actionToContinueWith)); return(Then(new ActionTask(Token, (s, ex) => { actionToContinueWith(s, ex); if (!s) { throw ex; } }) { Affinity = affinity, Name = "Finally" }, TaskRunOptions.OnAlways) .CatchInternal(_ => true)); }
public IProcessTask <string> NewMonoProcess(string executable, string arguments, ProcessOptions options = default, string workingDir = default, Action <IProcessTask <string> > onStart = null, Action <IProcessTask <string>, string> onOutput = null, Action <IProcessTask <string>, string, bool, Exception> onEnd = null, IOutputProcessor <string> outputProcessor = null, TaskAffinity affinity = TaskAffinity.None, CancellationToken token = default ) { return(ConfigureProcess( new MonoProcessTask <string>(TaskManager, localProcessManager.DefaultProcessEnvironment, Environment, executable, arguments, outputProcessor ?? new StringOutputProcessor()) { Affinity = affinity }, options, workingDir, onStart, onOutput, onEnd)); }
public static ITask Then <T>(this ITask <T> task, Action <bool, T> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, bool always = false) { Guard.ArgumentNotNull(continuation, "continuation"); return(new ActionTask <T>(task.Token, continuation, task, always) { Affinity = affinity, Name = $"Then<{typeof(T)}>" }); }
public static ITask <TRet> Then <T, TRet>(this ITask <T> task, Func <bool, T, TRet> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, bool always = false) { Guard.ArgumentNotNull(continuation, "continuation"); return(task.Then(new FuncTask <T, TRet>(task.Token, continuation) { Affinity = affinity, Name = $"Then<{typeof(T)}, {typeof(TRet)}>" }, always)); }
public static ITask <TRet> WithAsync <T, TRet>(this ITaskManager taskManager, Func <T, Task <TRet> > asyncDelegate, T state, TaskAffinity affinity = TaskAffinity.Concurrent, string name = null) { taskManager.EnsureNotNull(nameof(taskManager)); asyncDelegate.EnsureNotNull(nameof(asyncDelegate)); return(new TPLTask <T, TRet>(taskManager, asyncDelegate) { PreviousResult = state, Affinity = affinity, Name = name ?? $"WithAsync<{typeof(T)}, {typeof(TRet)}>" }); }
public static ITask WithAsync(this ITaskManager taskManager, Func <Task> asyncDelegate, TaskAffinity affinity = TaskAffinity.Concurrent, string name = "WithAsync") { taskManager.EnsureNotNull(nameof(taskManager)); asyncDelegate.EnsureNotNull(nameof(asyncDelegate)); return(new TPLTask(taskManager, asyncDelegate) { Affinity = affinity, Name = name }); }
public static ITask <TRet> With <T, TRet>(this ITaskManager taskManager, Func <T, TRet> continuation, T state, TaskAffinity affinity = TaskAffinity.Concurrent, string name = null) { taskManager.EnsureNotNull(nameof(taskManager)); continuation.EnsureNotNull(nameof(continuation)); return(new FuncTask <T, TRet>(taskManager, continuation) { PreviousResult = state, Affinity = affinity, Name = name ?? $"With<{typeof(T)}>" }); }
public static ITask <TRet> ThenAsync <T, TRet>(this ITask <T> task, Func <T, Task <TRet> > asyncDelegate, TaskAffinity affinity = TaskAffinity.Concurrent, string name = null, TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { task.EnsureNotNull(nameof(task)); asyncDelegate.EnsureNotNull(nameof(asyncDelegate)); var cont = new TPLTask <T, TRet>(task.TaskManager, asyncDelegate, token: task.Token) { Affinity = affinity, Name = name ?? $"ThenAsync<{typeof(T)}, {typeof(TRet)}>" }; return(task.Then(cont, runOptions)); }
public static ITask <T> Then <T>(this ITask task, Func <Task <T> > continuation, TaskAffinity affinity = TaskAffinity.Concurrent, bool always = false) { return(task.Then(continuation(), affinity, always)); }
public static ITask <TRet> Then <T, TRet>(this ITask <T> task, Func <bool, T, TRet> continuation, TaskAffinity affinity = TaskAffinity.Concurrent, TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { Guard.ArgumentNotNull(continuation, "continuation"); return(task.Then(new FuncTask <T, TRet>(task.Token, continuation) { Affinity = affinity, Name = $"Then<{typeof(T)}, {typeof(TRet)}>" }, runOptions)); }
public static IAwaitable AwaitOn(this Task task, ITaskManager taskManager, TaskAffinity affinity) => new ThreadingHelper.AwaitableWrapper(taskManager.GetScheduler(affinity));
public static ITask <T> Then <T>(this ITask task, Func <Task <T> > continuation, TaskAffinity affinity = TaskAffinity.Concurrent, TaskRunOptions runOptions = TaskRunOptions.OnSuccess) { return(task.Then(continuation(), affinity, runOptions)); }