/// 顺序执行
internal static async Task Excuting_Serial <TTData, TTRes>(this BaseNode <TTData, TTRes> node,
TTData data, NodeResp <TTRes> nodeResp, IList <IEventTask <TTData> > tasks, int triedTimes)
where TTData : class where TTRes : Resp, new()
{
nodeResp.TaskResults = new Dictionary <TaskMeta, TaskResp <Resp> >(tasks.Count);
nodeResp.node_status = NodeStatus.ProcessCompoleted; // 默认成功，给出最大值，循环内部处理
foreach (var tItem in tasks)
{
var taskResp = await ExecutorUtil.TryGetTaskItemResult(data, tItem, triedTimes);
var tMeta = tItem.TaskMeta;
nodeResp.TaskResults.Add(tMeta, taskResp);
var haveError = ExecutorUtil.FormatNodeErrorResp(nodeResp, taskResp, tMeta);
if (haveError)
{
nodeResp.block_taskid = tMeta.task_id;
break;
}
}
}
// 并行执行任务扩展
internal static async Task Excuting_Parallel <TTData, TTRes>(this BaseNode <TTData, TTRes> node, TTData data,
NodeResp <TTRes> nodeResp, IList <IEventTask <TTData> > tasks, int triedTimes)
where TTData : class
where TTRes : Resp, new()
{
var taskResults =
tasks.ToDictionary(t => t, t => ExecutorUtil.TryGetTaskItemResult(data, t, triedTimes));
try
{
await Task.WhenAll(taskResults.Select(tr => tr.Value));
}
catch (Exception ex)
{
LogUtil.Error(ex, node.NodeMeta.node_id, EventTaskProvider.ModuleName);
}
var taskResps = taskResults.ToDictionary(d => d.Key, d => d.Value.Status == TaskStatus.Faulted
? new TaskResp <Resp>().WithError(TaskRunStatus.RunFailed, new RunCondition())
: d.Value.Result);
nodeResp.TaskResults = taskResps.ToDictionary(tk => tk.Key.TaskMeta, tk => tk.Value);
nodeResp.node_status = NodeStatus.ProcessCompoleted; // 循环里会处理结果，这里给出最大值
foreach (var tItemRes in taskResps)
{
var isBlocked = ExecutorUtil.FormatNodeErrorResp(nodeResp, tItemRes.Value, tItemRes.Key.TaskMeta);
if (isBlocked)
{
nodeResp.block_taskid = tItemRes.Key.TaskMeta.task_id;
if (nodeResp.node_status == NodeStatus.ProcessFailedRevert)
{
break;
}
}
}
}
