Comment suivre si un async/awaitable tâche est en cours d'exécution

Je suis en train de faire la transition à partir de l'Événement-en fonction du Modèle Asynchrone où j'ai suivi l'exécution de méthodes utilisant les id unique et la asynoperationmanager.
Comme cela a maintenant été supprimés à partir de Windows 8 Applications que je vais essayer d'obtenir un effet similaire avec Async/Await, mais ne peut pas comprendre comment.

Ce que je suis en train de réaliser est quelque chose comme

private async Task updateSomething()
{
    if(***the method is already running***)
    {
        runagain = true;
    }
    else
    {
        await someMethod();
        if (runagain)
        {
            run the method again
        }            
    }
}

La partie, je suis mal, c'est de savoir si la méthode est en cours d'exécution. J'ai essayé de créer une Tâche et en regardant l'état de la fois que et la .le statut de la méthode asynchrone, mais ils ne semblent pas être le bon endroit pour chercher.
Grâce

Mise à JOUR: il s'agit du code que j'utilise dans .net 4 pour obtenir le même résultat. _updateMetaDataAsync est une classe basée sur l'Événement en Fonction du Modèle Asynchrone.

private void updateMetaData()
    {
        if (_updateMetaDataAsync.IsTaskRunning(_updateMetaDataGuid_CheckAllFiles))
        {
            _updateMetaDataGuid_CheckAllFiles_Again = true;
        }
        else
        {
            _updateMetaDataGuid_CheckAllFiles_Again = false;
            _updateMetaDataAsync.UpdateMetaDataAsync(_updateMetaDataGuid_CheckAllFiles);
        }
    }

private void updateMetaDataCompleted(object sender, UpdateMetaDataCompletedEventArgs e)
    {
        if (_updateMetaDataGuid_CheckAllFiles_Again)
        {
            updateMetaData();
        }
    }

OriginalL'auteur Oli | 2012-08-23

.net c#

7

async/await lui-même est destiné à être utilisé pour créer des opérations séquentielles exécutée de manière asynchrone du thread d'INTERFACE utilisateur. Vous pouvez faire les opérations en parallèle, mais en général, les opérations de "rejoindre" retour vers le thread d'INTERFACE utilisateur avec une sorte de résultat. (il y a aussi la possibilité de faire des "fire-and-forget" types d'opérations asynchrones avec await mais il n'est pas recommandé). c'est à dire il n'y a rien d'inhérent à async/await à l'appui de rapports sur les progrès réalisés.

Vous peut obtenir des progrès de code à l'aide de async/await; mais vous avez besoin d'utiliser de nouveaux progrès des interfaces comme IProgress<T>. Pour plus d'informations sur les rapports d'étape avec async/await, voir http://blogs.msdn.com/b/dotnet/archive/2012/06/06/async-in-4-5-enabling-progress-and-cancellation-in-async-apis.aspx. La migration vers ce doit juste être une question de faire appel à un IProgress délégué à la place d'un Progress événement.

Je n'utilise pas Async/Await par le biais de choix, plus parce que MS a jonchaient le .net pour windows API avec Async marqué méthodes. Est-il de toute façon pour éviter d'aller en bas de la async/await route?
Simplement parce qu'une méthode se termine dans Async ne signifie pas que vous devez utiliser await. Vous pouvez simplement utiliser la résultante Task et faire ce que vous voulez faire avec elle, comme ContinueWith. par exemple, webClient.DownloadStringAsync(myUri).ContinueWith(t=>Trace.WriteLine("done")); - pas de await.

OriginalL'auteur Peter Ritchie
2

Si vous utilisez un Task que vous avez créée, vous pouvez cocher la Tâche Statut propriété (ou tout simplement voir De la tâche.IsCompleted si l'achèvement est le seul état qui vous intéresse).

Cela étant dit, await ne sera pas un "retour" jusqu'à ce que l'opération soit terminée, déclenche une exception ou d'annulation. Vous pouvez supposer que, si vous êtes toujours en attente sur le "en attente", votre tâche n'est pas terminé.

Grâce Reed, seriez-vous en mesure de poster un peu de code car c'est exactement ce que j'ai essayé de le faire mais le statut dit toujours WaitingForActivation même si je sais que la tâche est en cours d'exécution. En gros, je veux 1 Tâche déclaré que j'pouvez ensuite affecter une méthode dans le constructeur. À partir d'une autre méthode de classe I peut alors démarrer et vérifier son statut, même si hésitez pas à indiquer une voie meilleure, si il y en a un.
C'est généralement une mauvaise idée d'avoir une Tâche qui n'a pas été commencé - le TPL et async/await est orientée avec le concept de tâches d'être toujours "à chaud", c'est pourquoi Task.Run est préféré au new Task. Quel est le réel but ici? (Non pas les mécanismes, mais ce que vous essayez d'accomplir)
J'ai essentiellement eu une longue tâche en cours d'exécution qui télécharge les informations de l'internet et des mises à jour des données sur les objets de l'application. L'application est mise à jour lorsque de nouveaux objets apparaissent et les demandes d'exécution de la tâche. Mon .net 4 logique avait une classe basée sur l'événement à base de modèle et a une instance de la classe déclarée (appelons cela methodasync) Donc, quand un objet est détecté il appelle methodasync.IsTaskRunning(l'id de la tâche). Il pas, il exécute la tâche, mais si elle est en cours d'exécution il s'agit d'un booléen qui dit qu'il doit exécuter de nouveau. Lorsque le methodasync se termine, il vérifie que le type bool et si "True", il s'exécute à nouveau.
Qu'en est juste de faire une file d'attente de délégués à l'annexe - puis en exécutant les éléments dans la file d'attente? Il semble beaucoup plus clair que d'essayer de "réexécuter" le sam eoperation, etc.
Voir ci-dessous concernant les Files d'attente 😉 Bien que la même méthode est à nouveau terme, c'est de travailler sur des objets différents à chaque fois. Si un 1000 objets viennent à la fois, je ne veux pas 1000 emplois. Le passage suivant serait de ramasser les 1000 objets et le travail ne serait pas complet mais je serais de gauche à 999 emplois restant à courir sans raison. J'ai mis à jour ma question avec l'actuel code que j'utilise pour des raisons de clarté.

OriginalL'auteur Reed Copsey

SemaphoreSlim queueToAccessQueue = new SemaphoreSlim(1);
object queueLock = new object();
long queuedRequests = 0;
Task _loadingTask;
public void RetrieveItems() {
  lock (queueLock) {
      queuedRequests++;
      if (queuedRequests == 1) { //1 is the minimum size of the queue before another instance is queued
        _loadingTask = _loadingTask?.ContinueWith(async () => {
          RunTheMethodAgain();
          await queueToAccessQueue.WaitAsync();
          queuedRequests = 0; //indicates that the queue has been cleared;
          queueToAccessQueue.Release()
        }) ?? Task.Run(async () => {
          RunTheMethodAgain();
          await queueToAccessQueue.WaitAsync();
          queuedRequests = 0; //indicates that the queue has been cleared;
          queueToAccessQueue.Release();
        });
      }
  }
}
public void RunTheMethodAgain() {
  ** run the method again **
}

L'avantage est que vous pouvez voir combien d'éléments sont assis dans la file d'attente!

OriginalL'auteur Toby Johnson

Vous devez vous connecter pour publier un commentaire.