De la tâche.ContinueWith méthode nécessite tâche argument?

J'ai une classe avec deux méthodes Load() et(). Je veux être en mesure d'exécuter ces individuellement, comme les tâches en arrière-plan, ou en séquence. J'aime la ContinueWith() de la syntaxe, mais je ne suis pas en mesure de le faire fonctionner. Je dois prendre un paramètre de Tâche sur la méthode que j'ai continuer et ne peut pas avoir un paramètre de Tâche sur la méthode initiale.

Je voudrais le faire sans les expressions lambda, mais je suis coincé à l'aide d'eux, en forçant un paramètre de tâche sur l'une des méthodes, ou la création d'une troisième méthode LoadAndProcess()?

void Run()
{
    //doesn't work, but I'd like to do it
    //Task.Factory.StartNew(MethodNoArguments).ContinueWith(MethodNoArguments);

    Console.WriteLine("ContinueWith");
    Task.Factory.StartNew(MethodNoArguments).ContinueWith(MethodWithTaskArgument).Wait();

    Console.WriteLine("Lambda");
    Task.Factory.StartNew(() => { MethodNoArguments(); MethodNoArguments(); }).Wait();

    Console.WriteLine("ContinueWith Lambda");
    Task.Factory.StartNew(MethodNoArguments).ContinueWith(x => { 
            MethodNoArguments(); 
        }).Wait();
}

void MethodNoArguments()
{
    Console.WriteLine("MethodNoArguments()");
}

void MethodWithTaskArgument(Task t = null)
{
    Console.WriteLine("MethodWithTaskArgument()");
}
Pourriez-vous expliquer pourquoi vous ne voulez pas utiliser des expressions lambda?
Je n'ai pas de vraie raison autre que j'aime la syntaxe de ContinueWith et pense que l'expression lambda rend moins regarder de plus en plus sale et un peu plus difficile à comprendre.
Ne Load et Process dépendent les uns des autres, de manière séquentielle? Est des données partagées entre eux, où la synchronisation des threads pourrait être le problème?
Otoh, que, avez-vous envisagé d'écrire votre propre ContinueWith(this Task, Action) méthode d'extension?
Gardez à l'esprit également que la poursuite reçoit une Tâche en tant que paramètre de sorte qu'il peut faire la gestion des exceptions. Pour une approche qui combine à la fois la syntaxe que vous voulez et assure exceptions sont propagées à travers la séquence de tâches et ne vont pas non gérée, jetez un oeil à la Then méthode Stephen Toub construit dans ce post.

OriginalL'auteur Jason Goemaat | 2012-05-17

  1. 14

    Dans tous les surcharges de ContinueWith(), le premier paramètre est un délégué qui prend un Task, de sorte que vous ne pouvez pas passer un sans paramètre délégué à.

    Je pense que l'aide de lambda est parfaitement bien et qu'il ne fait pas de mal la lisibilité. Et le lambda dans votre code est inutilement verbeux:

    Task.Factory.StartNew(MethodNoArguments).ContinueWith(_ => MethodNoArguments())

    Ou, comme Cory Carson l'a souligné dans un commentaire, on pourrait écrire une méthode d'extension:

    public static Task ContinueWith(this Task task, Action action)
{
    return task.ContinueWith(_ => action());
}

    OriginalL'auteur svick

  2. 4

    L'écriture de code propre lorsque vous utilisez plusieurs suites est pas facile, bien que vous pouvez suivre quelques règles pour rendre le code plus propre:

    1. Utiliser la forme courte de svick la réponse de
    2. Éviter d'enchaîner les continuations. Stocker le résultat de chaque poursuite dans une variable distincte et ensuite appeler ContinueWith dans une ligne distincte
    3. Si la poursuite de code est long, de le stocker dans une variable lambda et puis ContinueWith le lambda.
    4. Utiliser une méthode d'extension comme ce "Alors" méthode pour rendre votre code plus propre.

    Vous pouvez modifier votre code pour quelque chose de ce genre, qui est un peu plus propre:

            var call1=Task.Factory.StartNew(()=>MethodNoArguments());
        var call2 = call1.ContinueWith(_ => MethodNoArguments());
        call2.Wait();

    ou même

            var call1 = Task.Factory.StartNew<Task>(MethodNoArguments);
        var call2 = call1.Then(MethodNoArguments);
        call2.Wait();

    Stephen Toub traite de la vulgarisation et de d'autres façons que vous pouvez nettoyer votre code dans Le traitement des Séquences d'Opérations Asynchrones avec des Tâches

    Ce problème est résolu pour de bon en C# 4. En C# 5, vous pouvez utiliser la async/await mots-clés pour créer propre code qui ressemble à l'original de la version synchrone, par exemple:

        static async Task Run()
    {
        await MethodNoArguments();
        await MethodNoArguments();
    }

    static async Task MethodNoArguments()
    {
        await Task.Run(()=>Console.WriteLine("MethodNoArguments()"));
    }

    Visual Studio 11 et .NET 4.5 ont un Go Live licence de sorte que vous pourriez probablement commencer à les utiliser immédiatement.

    Vous pouvez utiliser la Async CTP en C# 4 pour obtenir le même résultat. Vous pouvez utiliser la Async CTP dans la production, comme il a un go live licence. L'inconvénient est que vous 'll ont à faire quelques petits changements à votre code lorsque vous vous déplacez .NET 4.5 en raison des différences entre le CTP et la .NET 4.5 (eg. CTP a TaskEx.Exécuter à la place de la Tâche.Exécuter).

    OriginalL'auteur Panagiotis Kanavos