寻找查看任务何时完成的最佳方法C#

Question

因此，我引入了一个项目列表，并为每个项目创建了一个对象实例，以在该项目上运行任务。所有的对象都是相同的，它们基于每三秒收到一条消息而更新。这个更新不会一次完成，有时需要3.1秒，等等。这是我需要在XML中序列化的数据，所以我正在寻找一种方法来查看所有这些都完成了。

我已经研究了.net 4.6中的任务，但它会启动一个任务，它会报告完成，然后要再次运行，任务类将再次启动它，但在我的例子中，这不会起作用，因为每个实例都会保持活动状态，并在新消息传入时启动自身。

最好的方法是让它报告它已到达最后一行代码，然后查看这些实例的列表，当所有实例都显示为完成时，然后运行任务进行序列化？

我已经在下面包含了正在运行的实例的代码。

private void OnMessageReceived(object sender, MessageReceivedEventArgs e)
        {
            var eventArgs = new CallDataReceivedEventArgs();
            this.OnCallDataReceived(eventArgs);

            try
            {
                List<Tuple<String, TimeSpan>> availInItems = new List<Tuple<string, TimeSpan>>();
                List<Tuple<string, int, TimeSpan, string, string, string>> agentlist = new List<Tuple<string, int, TimeSpan, string, string, string>>();

                if (e == null)
                {
                    return;
                }

                List<TimeSpan> listOfTimeSpans = new List<TimeSpan>();
                if (e.CmsData != null)
                {
                    #region Gathering Agent Information
                    // Create a list of all timespans for all _agents in a queue using the property AgentTimeInState

                    foreach (var item in e.CmsData.Agents)
                    {
                        //AgentData = new ScoreBoardAgentDataModel(AgentName, AgentExtension, AgentTimeInState, AgentAuxReason, AgentId, AgentAdcState);

                        _agentData.AgentName = item.AgName;

                        _agentData.AgentExtension = item.Extension;

                        _agentData.AgentAuxReason = item.AuxReasonDescription;

                        _agentData.AgentId = item.LoginId;

                        _agentData.AgentAcdState = item.WorkModeDirectionDescription;

                        _agentData.AgentTimeInState = DateTime.Now - item.DateTimeUpdated;

                        _agentData.TimeSubmitted = DateTime.Now;

                        agentlist.Add(Tuple.Create(_agentData.AgentName, _agentData.AgentExtension, _agentData.AgentTimeInState, _agentData.AgentId, _agentData.AgentAcdState, _agentData.AgentAuxReason));

                        if (_agentData.AgentAcdState == "AVAIL")
                        {
                            listOfTimeSpans.Add(_agentData.AgentTimeInState);

                            availInItems.Add(Tuple.Create(_agentData.AgentName, _agentData.AgentTimeInState));
                        }

                        availInItems.Sort((t1, t2) => t1.Item2.CompareTo(t2.Item2));
                    }

                    var availInAgents =
                        agentlist
                            .Where(ag => ag.Item5 == "AVAIL")
                            .ToList();

                    availInAgents.Sort((t1, t2) =>
                        t1.Item3.CompareTo(t2.Item3));

                    var max3 = availInAgents.Skip(availInAgents.Count - 3);

                    max3.Reverse();

                    _agents.AgentsOnBreak = 0;
                    foreach (var agent in agentlist)
                    {
                        if (!string.IsNullOrEmpty(agent.Item6) && agent.Item6.StartsWith("Break"))
                        {
                            _agents.AgentsOnBreak++;
                        }
                    }

                    _agents.AgentsOnLunch = 0;
                    foreach (var agent in agentlist)
                    {
                        //If the current agent's aux reason is Lunch
                        if (!string.IsNullOrEmpty(agent.Item6) && agent.Item6.StartsWith("Lunch"))
                        {
                            //add one to agentsonlunch
                            _agents.AgentsOnLunch++;
                        }
                    }

                    _agents.NextInLine = string.Empty;
                    foreach (var agent in max3.Reverse())
                    {
                        //assign agent to NextInLine and start a new line
                        _agents.NextInLine += agent.Item1 + Environment.NewLine;
                        //reverse NextInLine
                        _agents.NextInLine.Reverse();
                    }

                    _agents.TimeSubmitted = DateTime.Now;

                    #endregion

                    #region Gathering Skill Information

                    _skillData.OldestCall = e.CmsData.Skill.OldestCall;
                    _skillData.AgentsStaffed = e.CmsData.Skill.AgentsStaffed;
                    _skillData.AgentsAuxed = e.CmsData.Skill.AgentsInAux;
                    _skillData.AgentsAvailable = e.CmsData.Skill.AgentsAvailable;
                    _skillData.AgentsOnCalls = e.CmsData.Skill.AgentsOnAcdCall;
                    _skillData.CallsWaitingInQueue = e.CmsData.Skill.InQueueInRing;
                    _skillData.Asa = e.CmsData.Skill.AnswerTimePerAcdCall;
                    _skillData.TimeSubmitted = DateTime.Now;
                    _skillData.EstimatedHoldTimeLow = e.CmsData.Skill.ExpectedWaitTimeLow;
                    _skillData.EstimatedHoldTimeMedium = e.CmsData.Skill.ExpectedWaitTimeMedium;
                    _skillData.EstimatedHoldTimeHigh = e.CmsData.Skill.ExpectedWaitTimeHigh;     
                    #endregion

                }
            }
            catch (Exception ex)
            {
                _logger.Info(ex.Message, ex);
            }
        }

Answer 1

对于任务，您可以同时启动多个任务，并等待它们全部完成，如下所示：

var taskList = new List<Task>();

foreach (var thingToDo in work)
{
   taskList.Add(thingToDo.StartTask());
}

Task.WaitAll(taskList.ToArray());

这样你就可以并行运行所有的东西，直到所有的东西都完成了才会在最后一行之后运行。

根据您的评论进行编辑

您可以使用以下命令将工作嵌入到任务中：

public async Task DoWork() 
{
    var taskList = new List<Task>();

    foreach (var thingToDo in work)
    {
       taskList.Add(thingToDo.StartTask());
    }
    await Task.WhenAll(taskList.ToArray());
}