Essayez de l'Attraper à l'extérieur de l': attendre la Tâche.Exécuter(()

Ne try catch à l'extérieur de l': await Task.Run(() => sens ou tout simplement les utiliser uniquement à l'intérieur d'attendre?

private async void Test()
{
     try
     {
         await Task.Run(() =>
         {
             try
             {
                  DoingSomething();
             }
             catch (Exception ex)
             {
                  log.Error(ex.Message);
             }
         });
      }
      catch (Exception ex)
      {
          log.Error(ex.Message);
      }
}
Qui dépend entièrement de la façon dont vous pouvez gérer l'erreur.
Aussi, ne jamais écrire async void.
J'ai l'intention de rattraper toutes les erreurs insie od attendent mais est-il plus sûr d'ajouter Try Catch à l'extérieur de trop?
Quel est le problème avec async void (ou comment est-il différent de toute autre méthode void)?
msdn.microsoft.com/en-us/magazine/jj991977.aspx

OriginalL'auteur as74 | 2013-07-17

  1. 13

    Si vous manipulez des Exception à l'intérieur de la délégué (dans votre cas, juste pour l'enregistrement de but), await ne déclenche pas d'exception, dans des circonstances normales. Ce doit être fine.

    private async Task Test()
{
         await Task.Run(() =>
         {
             try
             {
                  DoingSomething();
             }
             catch (Exception ex)
             {
                  log.Error(ex.Message);
             }
         });

}

    Cependant, puisque vous êtes awaiting la Task, plus que probablement, il y aura quelques DoSomethingElse dans le Test méthode, qui risquent d'être touchés par l'issue de la Task - dans ce cas, il est également judicieux d'avoir un try/catch autour de await.

    private async Task Test()
{
     try
     {
         await Task.Run(() =>
         {
             try
             {
                  DoingSomething();
             }
             catch (SomeSpecialException spex)
             {
                  //it is OK to have this exception
                  log.Error(ex.Message);
             }
         });

         DoSomethingElse(); //does not run when unexpected exception occurs.
      }
      catch (Exception ex)
      {
          //Here we are also running on captured SynchronizationContext
          //So, can update UI to show error ....
      }
}
    J'ai essayé ceci dans une application console, et de mettre une pause dans la prise, il n'était pas dans le thread principal, je jette de nouveau et rien ne se passe. Je veux le thread principal pour obtenir de l'exception. comment puis-je faire cela?
    Application Console ne dispose pas d'un SynchronizationContext, donc le code après attendent peut s'exécuter sur n'importe quel thread. Si votre application WPF ou WinForms, à l'exception peut être soulevée en arrière sur le thread principal
    quelle est la meilleure stratégie pour une application console? Si une exception se produit dans le fond je veux l'app crash de dur, de sorte que les erreurs sont avalés en silence. Merci.
    Vous souhaitez app crash dur ou que vous ne voulez pas
    idéalement, je veux l'app crash dur sur toute exception inattendue.

    OriginalL'auteur YK1

  2. 8

    Si le délégué de passer Task.Run soulève une exception, alors vous pouvez l'attraper à l'extérieur de la Task.Run lorsque vous await le retour de l'tâche.

    Vous ne devriez pas penser à await comme s'il s'agissait d'un bloc. Il n'y a pas une telle chose comme "à l'intérieur de l'attendent". Au lieu de cela, pensez à await comme un opérateur qui prend un seul argument (dans ce cas, le Task retourné par Task.Run). Task.Run va attraper les exceptions à partir de son délégué et de les placer sur le revenu Task; await va se propagent alors que l'exception.

    Vous ne pouvez exception de catch à l'extérieur si le délégué est marqué comme async ( même si il n'y a pas d'attendre déclaration délégué) await Task.Run(async () => { throw new Exception("msg"); });
    Non, vous pouvez le prendre sans le async à l'intérieur de Task.Run.
    J'ai juste couru dans cette même situation. Je ne pouvais pas attraper un SQLException à l'extérieur de Task.Run à moins que j'ai ajouté le async mot-clé pour mon lambda
    C'est probablement que le débogueur s'arrête sur une exception "a été unhanded par le code de l'utilisateur".

    OriginalL'auteur Stephen Cleary

  3. 1

    Vous pouvez ajouter des try catch à l'extérieur code de trop. Le compilateur va exécuter la section catch lorsqu'une exception se produit lors de l'appel asynchrone. Voici plus de détails, pourquoi auriez-vous besoin d'essayer de l'attraper autour attendent http://msdn.microsoft.com/en-us/library/vstudio/0yd65esw.aspx regarder des Exceptions dans les Méthodes Asynchrones

    OriginalL'auteur Alexandr Mihalciuc