Comment faire pour déterminer si la Tâche.Run est terminé dans une boucle

Cela peut être une drôle de question et c'est vraiment mon but pédagogique afin que je puisse l'appliquer dans des scénarios d'avenir peut venir.

Je suis à l'aide de C#.

Je suis en stress test donc ce n'est pas tout à fait le code de production.

- Je télécharger des données sur mon serveur via un service web.

J'ai démarrer le service à l'aide d'une Exécution.De la tâche.

- Je vérifier pour voir si la Tâche est terminée avant de permettre à la prochaine course.Tâche pour commencer.

Ceci est fait dans une boucle.

Cependant, parce que je suis en utilisant un système modulaire déclaré Tâche ne sera pas le résultat d'être touché?
Je pourrais déclarer un travail locaux.Exécuter variable mais je veux voir jusqu'où je peux aller avec cette question, 1er.

Si la Tâche.Peut déclencher un événement à-dire qu'il est terminé, alors c'est peut-être pas un problème?

C'est mon code:

//déclaration de module:

private static Task webTask = Task.Run(() => { System.Windows.Forms.Application.DoEvents(); });

//dans la fonction appelée par l'intermédiaire d'un minuteur

if (webTask.IsCompleted)
{
   //keep count of competed tasks
}


webTask = Task.Run(() =>
{
    try 
    { 
         wcf.UploadMotionDynamicRaw(bytes);  //my web service
    }
    catch (Exception ex)
    {
        //deal with error
    }
);

Utiliser les Tâche de Continuation. Il existe différents modi. L'un d'eux est faire quelque chose après la tâche est terminée. OMI, vous n'avez pas besoin de la minuterie - modifiez votre code pour webTask.ContinueWith....
SALUT, merci pour aquick réponse. Je vais regarder cela maintenant et rapport - merci 🙂
alors quand j'ai modifier mon code:
webTask = nouvelle Tâche(wcf.UploadMotionDynamicRaw(octets));
Il me donne une erreur " impossible de convertir de 'void' à 'Action'?

OriginalL'auteur Andrew Simpson | 2015-01-04

c#task

9

De l'OMI, vous n'avez pas besoin de la minuterie. À l'aide de Continuation De Tâche vous abonnez-vous à la fait événement:
```
System.Threading.Tasks.Task
.Run(() => 
{
    //simulate processing
    for (var i = 0; i < 10; i++)
    {
        Console.WriteLine("do something {0}", i + 1);
    }
})
.ContinueWith(t => Console.WriteLine("done."));
```
La sortie est:
```
do something 1
do something 2
.
.
do something 9
do something 10
done
```
Votre code pourrait ressembler à ceci:
```
var webTask = Task.Run(() =>
{
    try 
    { 
        wcf.UploadMotionDynamicRaw(bytes);  //my web service
    }
    catch (Exception ex)
    {
        //deal with error
    }
}).ContinueWith(t => taskCounter++);
```
Avec continuation de tâche vous pouvez même différencier échoué et succès résultat du processus, si vous voulez compter seulement succès de tâches à l'aide de la TaskContinuationOptrions.

Salut, j'ai été en utilisant la minuterie juste pour les tests de stress et complètement d'accord avec vous. L'exemple sur MSDN est différente de la vôtre, et je préfère la vôtre. Beaucoup plus claire. Merci
Serait la downvoter veuillez expliquer?

OriginalL'auteur pasty

Vous pouvez attendre votre tâche à remplir par l'attente de votre tâche de cette

await webTask;

qui asynchrone attendre 'webTask' pour terminer. Au lieu de la minuterie vous pouvez utiliser await Task.Delay qui asynchrone d'attendre le délai d'expiration. Je voudrais également envisager de faire de la wcf appel asynchrone de sorte que vous n'avez pas à appeler à l'intérieur de Task.Run. Voir cette question pour quelques conseils.

J'avais réécrire le code comme suit:

public async Task UploadAsync()
{
    while(true)
    {
        await Task.Delay(1000); //this is essentially your timer

        //wait for the webTask to complete asynchrnously
        await webTask;

        //keep count of competed tasks

        webTask = Task.Run(() =>
                        {
                            try 
                            { 
                                //consider generating an asynchronous method for this if possible.
                                wcf.UploadMotionDynamicRaw(bytes);  //my web service
                            }
                            catch (Exception ex)
                            {
                                //deal with error
                            }
                        });     
    }
}

Bonjour, merci pour la réponse. Très apprécié. J'étais au courant de l'attendent, mais je voulais avoir asynchrone. La raison de tout cela est de vérifier si le serveur web est de suivre mes appels répétitifs. Par le suivi de la file d'attente, je peux (j'espère) de détecter cela.

OriginalL'auteur Ned Stoyanov

Vous devez vous connecter pour publier un commentaire.