Je veux la Tâche de gérer toutes les exceptions qui sont levées, mais je trouve qu'il est difficile pour les empêcher d'atteindre le parent

Je suis en train de travailler sur un Web Crochet.NET 4.0 qui exécute un lambda de manière asynchrone et puis d'afficher le résultat d'une URI quand c'est fini.

J'ai qu'à travailler, mais maintenant je veux la Tâche de gérer toutes les exceptions qui sont levées, et je suis de trouver qu'il est difficile pour les empêcher d'atteindre le parent.

Voici la partie de mon code:

private readonly Func<T> _startTask;
private readonly string _responseUri;

public Task<T> Begin()
{
    var task = new Task<T>(_startTask);
    task.ContinueWith<T>(End);
    task.Start();
    return task;
}

private T End(Task<T> task)
{
    if (task.IsFaulted)
    {
        return HandleException(task);
    }

    var result = task.Result;
    WebHookResponse.Respond(result, _responseUri);
    return result;
}

private T HandleException(Task<T> task)
{
    WebHookResponse.HandleException(task.Exception.InnerException, _responseUri);
    return null;
}

Une autre version que j'ai essayé appels ContinueWith() deux fois pour enregistrer une poursuite pour exécuter OnlyOnRanToCompletion et une autre OnlyOnFaulted. (Je ne suis pas sûr si l'appel de ContinueWith() deux fois, c'est correct.):

public Task<T> Begin()
{
    var task = new Task<T>(_startTask);
    task.ContinueWith<T>(End, TaskContinuationOptions.OnlyOnRanToCompletion);
    task.ContinueWith<T>(HandleException, TaskContinuationOptions.OnlyOnFaulted);
    task.Start();
    return task;
}

private T End(Task<T> task)
{
    var result = task.Result;
    WebHookResponse.Respond(result, _responseUri);
    return result;
}

private T HandleException(Task<T> task)
{
    WebHookResponse.HandleException(task.Exception.InnerException, _responseUri);
    return null;
}

Donc, fondamentalement, je veux un moyen pour chaque Tâche de gérer ses propres exceptions via une fonction de prolongement. Comme il est le HandlException la continuation de la fonction n'est jamais appelée, dans les exemples ci-dessus.

Je suis causant des exceptions dans des cas de test, et je dois préciser que je suis en utilisant un Tasks.WaitAll(tasks); appel sur un tableau de Tâches pour s'assurer que toutes les tâches sont terminées avant de faire mes affirmations, et je ne suis pas sûr si cet appel fait une différence à la façon dont les exceptions sont gérées par les Tâches. Actuellement WaitAll jette un AggregationException qui regroupe les exceptions pour chacune des Tâches parce qu'ils ne sont pas gérés par le HandleException fonction de prolongement.

Je ne vois pas le problème. Quel comportement avez-vous observé?
Désolé, le HandleException la continuation de la fonction n'est pas appelée. Un AggregationException est jeté par les Tâches.WaitAll(tâches); appel. Je ne veux pas voir un AggregationException. Je viens de mettre à jour la question.
Owen Bonjour, mon HandleExceptionContinuation n'est pas d'être appelé trop et ma UnobservedTaskException événement n'est pas déclenché trop ici : stackoverflow.com/questions/11831844/... avez-vous trouvé une solution ?
Aussi méfiez-vous d'un risque de fuite de mémoire si vous utilisez des poursuites qui ne sont pas d'exécution en combinaison avec un jeton d'annulation.

OriginalL'auteur Martin Owen | 2010-07-19

  1. 3

    Une tâche de poursuite qui observe la tâche de l'exception ne doit pas gérer l'exception. Il arrive encore sur où que vous attendez sur la fin de la tâche.

    Vous dit que vous étiez en appelant WaitAll(tâches) avant d'affirmer. Je parie que votre poursuite aurait couru si vous lui avez donné assez de temps, mais à l'exception sur WaitAll() est généralement va se produire avant votre poursuite s'exécute. Si votre affirme probablement échoué avant votre poursuite a été donné une chance de terminer ses travaux.

    OriginalL'auteur Ross

  2. 1

    Peut-être, à la réponse de Henk Holterman, le ordre fait une différence. C'est,

    var task = new Task<T>(_startTask);
task = task.ContinueWith<T>(HandleException, TaskContinuationOptions.OnlyOnFaulted);
task = task.ContinueWith<T>(End, TaskContinuationOptions.OnlyOnRanToCompletion);
task.Start();

    serait de s'assurer que HandleException irait si nécessaire.

    Non, il n'est pas. Les deux continuations sera appelée si nécessaire, quel que soit l'ordre dans lequel vous avez appelé ContinueWith (évidemment, seulement un, à chaque fois depuis leur TaskContinuationOptions sont mutuellement exclusif).
    Si vous l'avez fait dans cet ordre, les exceptions que agrégée en Fin ne pourra être traité. HandleException doit toujours être le dernier appelé, comme un balai dans le football est derrière tout la défense de sorte qu'il peut balayer tout ce qui peut passer à travers, la même chose.

    OriginalL'auteur Albino Cordeiro

  3. 1

    - Je utiliser cette approche, car elle offre une belle déclarative couramment le style de codage et de ne pas la litière de votre code, à l'exception de la manipulation aspects.

    class Program
{
    static void Main()
    {
        Task.Factory.StartNew(
            () =>
                {
                    throw new Exception();
                })
            .Success(() => Console.WriteLine("Works"))
            .Fail((ex) => Console.WriteLine("Fails")).Wait();

        Console.ReadKey();
    }
}

public static class TaskExtensions
{
    public static Task Success(this Task task, Action onSuccess)
    {
        task.ContinueWith((t) =>
        {
            if (!t.IsFaulted)
            {
                onSuccess();
            }
        });

        return task;
    }

    public static Task Fail(this Task task, Action<Exception> onFail)
    {
        return task.ContinueWith(
            (t) =>
            {
                if (t.IsFaulted)
                {
                    t.Exception.Handle(x => true);
                    onFail(t.Exception.Flatten());
                }
            });
    }
}

    OriginalL'auteur Jason Bowers