寻找查看我的任务何时完成的最佳方法 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());
}