Comment faire pour déterminer quand la tâche est terminée

voici un exemple de code pour le démarrage de la tâche multiple

Task.Factory.StartNew(() =>
        {
            //foreach (KeyValuePair<string, string> entry in dicList)

            Parallel.ForEach(dicList,
                entry =>
                {

                    //create and add the Progress in UI thread
                    var ucProgress = (Progress)fpPanel.Invoke(createProgress, entry);

                    //execute ucProgress.Process(); in non-UI thread in parallel. 
                    //the .Process(); must update UI by using *Invoke
                    ucProgress.Process();

                    System.Threading.Thread.SpinWait(5000000);
                });
        });
.ContinueWith(task => 
  {
      //to handle exceptions use task.Exception member

      var progressBar = (ProgressBar)task.AsyncState;
      if (!task.IsCancelled)
      {
          //hide progress bar here and reset pb.Value = 0
      }
  }, 
  TaskScheduler.FromCurrentSynchronizationContext() //update UI from UI thread
  );

quand nous commençons à de multiples tâches à l'aide de Task.Factory.StartNew() ensuite, nous pouvons utiliser .ContinueWith() bloc pour déterminer le moment où chaque tâche de finition. je veux dire ContinueWith bloc feu une fois pour chaque réalisation de la tâche. donc, je veux juste savoir est-il un mécanisme de TPL de la bibliothèque. si je commence à 10 tâche à l'aide de Task.Factory.StartNew() alors, comment dois-je aviser après 10 tâche sera fini. veuillez donner un aperçu des exemples de code.

- Ils doivent être exécutés l'un après l'autre?

OriginalL'auteur Thomas | 2013-06-10

c#task-parallel-library

22

si je commence à 10 tâche à l'aide de la Tâche.Usine.StartNew() alors, comment dois-je aviser après 10 tâche sera fini

Trois options:
- Le blocage Tâche.WaitAll appel, qui retourne uniquement lorsque toutes les tâches ont terminé
- Async Tâche.WhenAll appel, qui retourne une tâche qui se termine lorsque toutes les tâches ont terminé. (Introduit en .NET 4.5.)
- TaskFactory.ContinueWhenAll, ce qui ajoute une continuation de la tâche qui sera exécutée lorsque toutes les tâches ont terminé.
TaskFactory.ContinueWhenAll(...) est pratique aussi, si vous êtes limité à 4.0.
Ooh, nice - raté, va l'ajouter.
je travaille dans la version net 4.0. je veux commencer à 10 tâche et je veux être en aviser lors de chaque tâche sera achevé et aussi une dernière notification devrait se faire lorsque 10 tâche sera terminée. merci de me donner une idée. merci
Il semble que vous voulez ContinueWith sur chaque tâche, puis un appel à ContinueWhenAll ainsi avec le "tout est accompli" de notification.
merci. u peut me donner un indice ou un exemple de code pour l'utilisation de ContinueWhenAll() & ContinueWith() togather.

OriginalL'auteur Jon Skeet
2

si je commence à 10 tâche à l'aide de la Tâche.Usine.StartNew() alors, comment dois-je aviser après 10 tâche sera fini

Vous pouvez utiliser De la tâche.WaitAll. Cet appel va bloquer le thread courant jusqu'à ce que toutes les tâches sont terminées.

Note de côté: vous semblez être à l'aide de Task, Parallel et Thread.SpinWait, ce qui rend votre code plus complexe. Je voudrais passer un peu de temps à analyser si cette complexité est vraiment nécessaire.

je travaille dans la version net 4.0. je veux commencer à 10 tâche et je veux être en aviser lors de chaque tâche sera achevé et aussi une dernière notification devrait se faire lorsque 10 tâche sera terminée. merci de me donner une idée. merci
Je voudrais ajouter un .ContinueWith pour chaque tâche d'envoyer une notification sur l'achèvement du travail et une dernière ligne serait Task.WaitAll(). En d'autres termes, chaque tâche fournit une notification lorsque vous avez terminé en utilisant les tâches de l'enchaînement, où l'enchaînement des tâches simplement des rapports sur l'achèvement. Il y aura aussi un appel à la Task.WaitAll méthode - ce qui vous permettra de faire une notification à propos de toutes les tâches d'achèvement des travaux. Un sens?

OriginalL'auteur oleksii

Vous pouvez utiliser le WaitAll(). Exemple :

Func<bool> DummyMethod = () =>{
    //When ready, send back complete!
    return true;
};

//Create list of tasks
System.Threading.Tasks.Task<bool>[] tasks = new System.Threading.Tasks.Task<bool>[2];

//First task
var firstTask = System.Threading.Tasks.Task.Factory.StartNew(() => DummyMethod(), TaskCreationOptions.LongRunning);
tasks[0] = firstTask;

//Second task
var secondTask = System.Threading.Tasks.Task.Factory.StartNew(() => DummyMethod(), TaskCreationOptions.LongRunning);
tasks[1] = secondTask;

//Launch all
System.Threading.Tasks.Task.WaitAll(tasks);

Le "<" et ">" n'apparaissent pas. Essaie ici : Func<bool> DummyMethod = () =>{ // Quand il est prêt, envoyez le retour complet! return true; };
Je pense que le “Lancer” commentaire est assez déroutant, car WaitAll() n'est pas réellement lancer quoi que ce soit.
je travaille dans la version net 4.0. je veux commencer à 10 tâche et je veux être en aviser lors de chaque tâche sera achevé et aussi une dernière notification devrait se faire lorsque 10 tâche sera terminée. merci de me donner une idée. merci

OriginalL'auteur Mez

0

Une autre solution:

Après l'achèvement de l'ensemble de l'opération à l'intérieur de Parallel.For(...) retourner un onject de ParallelLoopResult, La Documentation:

Pour les retours un Système.Le filetage.Les tâches.ParallelLoopResult de l'objet lors de
tous les threads ont terminé. Cette valeur de retour est utile lorsque vous êtes
l'arrêt ou de la rupture de boucle d'itération manuellement, car le
ParallelLoopResult stocke des informations telles que la dernière itération
a couru à la fin. Si une ou plusieurs des exceptions se produisent sur l'un des
threads, un Système.AggregateException sera levée.

La ParallelLoopResult classe a un IsCompleted propriété est définie à false quand un Stop() de Break() méthode a été exécuté.

Exemple:
```
ParallelLoopResult result = Parallel.For(...);

if (result.IsCompleted)
{
    //Start another task
}
```
Noter qu'il est préférable de l'utiliser uniquement lorsque la rupture ou de stopper la boucle manuellement (sinon il suffit d'utiliser WaitAll, WhenAll etc).

OriginalL'auteur Shahar Shokrani

Vous devez vous connecter pour publier un commentaire.