auf der Suche nach dem besten Weg zu sehen, wenn meine Aufgabe abgeschlossen ist C#

Question

So ziehe ich eine Liste von Elementen und für jedes Element Ich erstelle eine Instanz eines Objekts, um eine Aufgabe für dieses Element auszuführen. Alle Objekte sind gleich, sie werden alle drei Sekunden basierend auf einer empfangenen Nachricht aktualisiert. Dieses Update findet nicht immer auf einmal statt, manchmal dauert es 3,1 Sekunden usw. Dies sind Daten, die ich in XML serialisieren muss, sobald alles vorhanden ist, also suche ich nach einer Möglichkeit zu sehen, wann alles fertig ist.

Ich habe Aufgaben in .net 4.6 erkundet, aber das initiiert eine Aufgabe und es meldet abgeschlossen und dann wieder zu starten die Task-Klasse würde es erneut initiieren, aber in meinem Fall wird das nicht funktionieren, weil jede Instanz am Leben und initiiert bleibt selbst wenn eine neue Nachricht kommt.

Was ist der beste Weg, um es zu melden, erreichte die letzte Zeile des Codes und dann eine Liste dieser Instanzen zu sehen und sagen, wenn alle von ihnen zeigen, dann führen Sie Task zu serialisieren?

Ich habe den folgenden Code der laufenden Instanz hinzugefügt.

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

Mit Aufgaben können Sie viele zur gleichen Zeit beginnen und auf sie warten alle so beenden:

var taskList = new List<Task>(); 

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

Task.WaitAll(taskList.ToArray()); 

diese Weise können Sie alles parallel und werden nicht erhalten nach der letzten Zeile laufen können, bis es ist alles erledigt.

bearbeiten nach Ihren Kommentar

Sie können Ihre Arbeit in einer Aufgabe mit diesem einbetten:

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

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