C# 正在寻找最好的方法来查看我的任务何时完成#

所以我拉入一个项目列表，并为每个项目创建一个对象实例，以在该项目上运行任务。所有对象都是相同的，它们根据每三秒收到的消息进行更新。不过，这个更新并不是一次完成的，有时需要3.1秒，等等。这些数据一旦全部存在，我就需要用XML序列化，所以我正在寻找一种方法来查看它何时完成

我在.net 4.6中探讨了任务，但这会启动一个任务并报告已完成，然后再次运行任务类会再次启动它，但在我的情况下，这不会起作用，因为每个实例都保持活动状态，并在收到新消息时自行启动

让it报告它已到达最后一行代码，然后查看这些实例的列表，并说明何时所有实例都显示为已完成，然后运行任务进行序列化的最佳方法是什么

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

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

messagereceived上的私有void（对象发送方，MessageReceivedEventArgs e）
{
var eventArgs=new CallDataReceivedEventArgs（）；
此.OnCallDataReceived（eventArgs）；
尝试
{
列表可用项=新列表（）；
List agentlist=新列表（）；
如果（e==null）
{
返回；
}
List listOfTimeSpans=新列表（）；
如果（e.CmsData！=null）
{
#区域收集代理信息
//使用属性AgentTimeInState为队列中的所有_代理创建所有时间跨度的列表
foreach（e.CmsData.Agents中的var项）
{
//AgentData=新记分板AgentData模型（AgentName、AgentExtension、AgentTimeInState、AgentAuxReason、AgentId、AgentAcState）；
_agentData.AgentName=item.AgName；
_agentData.AgentExtension=item.Extension；
_agentData.AgentAuxReason=item.AuxReasonDescription；
_agentData.AgentId=item.LoginId；
_agentData.agentadstate=item.WorkModeDirectionDescription；
_agentData.AgentTimeInState=DateTime.Now-item.DateTimeUpdate；
_agentData.TimeSubmitted=DateTime.Now；
添加（Tuple.Create（_agentData.AgentName、_agentData.AgentExtension、_agentData.AgentTimeInState、_agentData.AgentId、_agentData.agentadstate、_agentData.agentaxreason））；
如果（_agentData.agentadstate==“AVAIL”）
{
添加（_agentData.AgentTimeInState）；
Add（Tuple.Create（_agentData.AgentName，_agentData.AgentTimeInState））；
}
排序（（t1，t2）=>t1.Item2.CompareTo（t2.Item2））；
}
var有效剂=
代理列表
.Where（ag=>ag.Item5==“AVAIL”）
.ToList（）；
Availiangents.Sort（（t1，t2）=>
t1.项目3.比较（t2.项目3））；
var max3=availingents.Skip（availingents.Count-3）；
max3.Reverse（）；
_agents.AgentsOnBreak=0；
foreach（代理列表中的var代理）
{
如果（！string.IsNullOrEmpty（agent.Item6）和&agent.Item6.StartsWith（“Break”））
{
_agents.AgentsOnBreak++；
}
}
_agents.AgentsOnLunch=0；
foreach（代理列表中的var代理）
{
//如果当前代理的辅助原因是午餐
如果（！string.IsNullOrEmpty（agent.Item6）和&agent.Item6.StartsWith（“午餐”））
{
//将一个添加到agentsonlunch
_agents.AgentsOnLunch++；
}
}
_agents.NextInLine=string.Empty；
foreach（max3.Reverse（）中的var代理）
{
//将代理分配给NextInLine并启动新行
_agents.NextInLine+=agent.Item1+Environment.NewLine；
//下一行
_agents.NextInLine.Reverse（）；
}
_agents.TimeSubmitted=DateTime.Now；
#端区
#区域收集技能信息
_skillData.OldestCall=e.CmsData.Skill.OldestCall；
_skillData.agentstaffed=e.CmsData.Skill.agentstaffed；
_skillData.AgentsAuxed=e.CmsData.Skill.agentsux；
_skillData.AgentsAvailable=e.CmsData.Skill.agentsailable；
_skillData.AgentsOnCalls=e.CmsData.Skill.agentsonaccall；
_skillData.CallsWaitingInQueue=e.CmsData.Skill.InQueueInRing；
_skillData.Asa=e.CmsData.Skill.answertimeperaccall；
_skillData.TimeSubmitted=DateTime.Now；
_skillData.EstimatedHoldTimeLow=e.CmsData.Skill.ExpectedWaitTimeLow；
_skillData.EstimatedHoldTimeMedium=e.CmsData.Skill.ExpectedWaitTimeMedium；
_skillData.EstimatedHoldTimeHigh=e.CmsData.Skill.ExpectedWaitTimeHigh；
#端区
}
}
捕获（例外情况除外）
{
_logger.Info（例如消息，例如）；
}
}

对于任务，您可以同时启动多个任务，然后像这样等待它们全部完成：

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