Gérer de façon élégante l'annulation de tâches

Lors de l'utilisation de tâches pour les gros/long cours d'exécution des charges de travail que j'ai besoin d'être en mesure de l'annuler, j'utilise souvent un modèle similaire à ce que l'action la tâche s'exécute:

public void DoWork(CancellationToken cancelToken)
{
    try
    {
        //do work
        cancelToken.ThrowIfCancellationRequested();
        //more work
    }
    catch (OperationCanceledException)
    {
        throw;
    }
    catch (Exception ex)
    {
        Log.Exception(ex);
        throw;
    }
}

La OperationCanceledException ne doit pas être enregistré comme une erreur, mais il ne doit pas être avalé si la tâche est de faire la transition vers l'annulation de l'état. Toutes les autres exceptions ne doivent pas être traitées au-delà de la portée de cette méthode.

Ce toujours senti un peu maladroit, et visual studio, par défaut, pause sur le lancer pour OperationCanceledException (Bien que j'ai une pause de l'Utilisateur-non gérée " éteint maintenant pour OperationCanceledException à cause de mon utilisation de ce modèle).

Idéalement, je pense que j'aimerais être capable de faire quelque chose comme ceci:

public void DoWork(CancellationToken cancelToken)
{
    try
    {
        //do work
        cancelToken.ThrowIfCancellationRequested();
        //more work
    }
    catch (Exception ex) exclude (OperationCanceledException)
    {
        Log.Exception(ex);
        throw;
    }
}

c'est à dire avoir une sorte de liste d'exclusion appliquée à la capture, mais sans le support de la langue qui n'est pas possible actuellement (@eric-lippert: c# vNext fonctionnalité :)).

Un autre moyen serait par le biais d'une poursuite:

public void StartWork()
{
    Task.Factory.StartNew(() => DoWork(cancellationSource.Token), cancellationSource.Token)
        .ContinueWith(t => Log.Exception(t.Exception.InnerException), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
}

public void DoWork(CancellationToken cancelToken)
{
    //do work
    cancelToken.ThrowIfCancellationRequested();
    //more work
}

mais je n'aime pas vraiment que l'exception peut techniquement avoir plus qu'une seule exception interne et vous n'avez pas autant de contexte lors de la connexion de l'exception comme vous le feriez dans le premier exemple (si je faisais plus que juste de l'enregistrement).

Je comprends que c'est un peu une question de style, mais vous vous demandez si quelqu'un a une meilleure suggestion?

Dois-je rester avec l'exemple 1?

Eamon

  • J'utilise une solution où la structure de journalisation faire des choses différentes pour certaines exceptions. c'est à dire ignorer OperationCancelledException, aplatit AggregateException, des journaux uniquement innerException pour InvalidOperationException etc
InformationsquelleAutor Eamon | 2012-09-28
  1. 15

    Donc, quel est le problème? Jeter de la catch (OperationCanceledException) bloc, et de définir la bonne continuations:

    var cts = new CancellationTokenSource();
var task = Task.Factory.StartNew(() =>
    {
        var i = 0;
        try
        {
            while (true)
            {
                Thread.Sleep(1000);

                cts.Token.ThrowIfCancellationRequested();

                i++;

                if (i > 5)
                    throw new InvalidOperationException();
            }
        }
        catch
        {
            Console.WriteLine("i = {0}", i);
            throw;
        }
    }, cts.Token);

task.ContinueWith(t => 
        Console.WriteLine("{0} with {1}: {2}", 
            t.Status, 
            t.Exception.InnerExceptions[0].GetType(), 
            t.Exception.InnerExceptions[0].Message
        ), 
        TaskContinuationOptions.OnlyOnFaulted);

task.ContinueWith(t => 
        Console.WriteLine(t.Status), 
        TaskContinuationOptions.OnlyOnCanceled);

Console.ReadLine();

cts.Cancel();

Console.ReadLine();

    TPL distingue de l'annulation et de la faute. Par conséquent, l'annulation (c'est à dire lancer OperationCancelledException cadre de la task corps) n'est pas une faute.

    Le point principal: ne pas gérer les exceptions dans la tâche corps sans re-jeter.

    • Mon seul problème avec la poursuite de la méthode est que je perds du contexte. par exemple, Si j'étais le traitement d'une liste d'Éléments et je besoin pour ouvrir une session dans quelle mesure grâce à la collection que j'étais lors de la levée de l'exception. Je n'ai raté quelque chose dans ma question initiale que j'ai fied maintenant et qui a été un relever de l'Exception ex pour permettre la tâche de faire la transition à l'état Faulted.
    • J'ai mis à jour la réponse avec try-catch-throw.
    • Il y a quelques réponses simples ci-dessous.
    InformationsquelleAutor Dennis
  2. 9

    Ici est de savoir comment vous gérer de façon élégante l'annulation de Tâches:

    Manipulation "fire-and-forget" Tâches

    var cts = new CancellationTokenSource( 5000 );  //auto-cancel in 5 sec.
Task.Run( () => {
    cts.Token.ThrowIfCancellationRequested();

    //do background work

    cts.Token.ThrowIfCancellationRequested();

    //more work

}, cts.Token ).ContinueWith( task => {
    if ( !task.IsCanceled && task.IsFaulted )   //suppress cancel exception
        Logger.Log( task.Exception );           //log others
} );

    Manipulation attendent l'achèvement de la Tâche /annulation

    var cts = new CancellationTokenSource( 5000 ); //auto-cancel in 5 sec.
var taskToCancel = Task.Delay( 10000, cts.Token );  

//do work

try { await taskToCancel; }           //await cancellation
catch ( OperationCanceledException ) {}    //suppress cancel exception, re-throw others
    InformationsquelleAutor Casey Anderson
  3. 6

    C# 6.0 a une solution pour cela..Filtrage d'exception

    int denom;

try
{
     denom = 0;
    int x = 5 / denom;
}

//Catch /0 on all days but Saturday

catch (DivideByZeroException xx) when (DateTime.Now.DayOfWeek != DayOfWeek.Saturday)
{
     Console.WriteLine(xx);
}
    • Le mot-clé est en fait "quand" et non pas "si". La syntaxe (pour l'OP) serait: catch( Exception ex ) quand (!(ex est OperationCanceledException))
    InformationsquelleAutor user5628548
  4. 1

    Selon ce blog MSDN, vous devez attraper OperationCanceledException, par exemple

    async Task UserSubmitClickAsync(CancellationToken cancellationToken)
{
   try
   {
      await SendResultAsync(cancellationToken);
   }
   catch (OperationCanceledException) //includes TaskCanceledException
   {
      MessageBox.Show(“Your submission was canceled.”);
   }
}

    Si votre annulable méthode est entre autres opérations annulables, vous devrez peut-être effectuer nettoyer en cas d'annulation. En faisant cela, vous pouvez utiliser le haut bloc catch, mais assurez-vous de renvoyer correctement:

    async Task SendResultAsync(CancellationToken cancellationToken)
{
   try
   {
      await httpClient.SendAsync(form, cancellationToken);
   }
   catch (OperationCanceledException)
   {
      //perform your cleanup
      form.Dispose();

      //rethrow exception so caller knows you’ve canceled.
      //DON’T “throw ex;” because that stomps on 
      //the Exception.StackTrace property.
      throw; 
   }
}
    InformationsquelleAutor Bondolin
  5. 0

    Vous pourriez faire quelque chose comme ceci:

    public void DoWork(CancellationToken cancelToken)
{
    try
    {
        //do work
        cancelToken.ThrowIfCancellationRequested();
        //more work
    }
    catch (OperationCanceledException) when (cancelToken.IsCancellationRequested)
    {
        throw;
    }
    catch (Exception ex)
    {
        Log.Exception(ex);
        throw;
    }
}
    InformationsquelleAutor Jesper Meyer
  6. -3

    Je ne suis pas entièrement sûr de ce que vous essayez d'atteindre d'ici, mais je pense que le modèle suivant peut aider à

    public void DoWork(CancellationToken cancelToken)
{
    try
    {
        //do work
        cancelToken.ThrowIfCancellationRequested();
        //more work
    }
    catch (OperationCanceledException) {}
    catch (Exception ex)
    {
        Log.Exception(ex);
    }
}

    Vous avez pu le constater, que j'ai supprimé l'instruction throw à partir d'ici. Ce ne sera pas jeter l'exception mais tout simplement de l'ignorer.

    Laissez-moi savoir si vous avez l'intention de faire quelque chose d'autre.

    Il y a encore une autre façon qui est assez proche de ce que vous avez exposé dans votre code

        catch (Exception ex)
    {
        if (!ex.GetType().Equals(<Type of Exception you don't want to raise>)
        {
            Log.Exception(ex);

        }
    }
    • Ce: catch (OperationCanceledException) {} sera de définir la tâche du statut RanToCompletion, pas comme Canceled. Il y a des cas d'utilisation, lorsque cette différence est importante.
    InformationsquelleAutor Murtuza Kabul