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));
}
