有没有办法使用 ContinueWith 任务启动任务？

Question

我的代码：

var r = from x in new Task<int>(() => 1)
        from y in new Task<int>(() => x + 1) 
        select y;
r.ContinueWith(x => Console.WriteLine(x.Result)).Start();   

或

new Task<int>(() => 1)
    .ContinueWith(x => x.Result + 1)
    .ContinueWith(x => Console.WriteLine(x.Result))
    .Start();

例外：

不能在继续任务上调用开始。

所以我需要开始第一个任务。有没有办法调用last task的Start方法来运行所有的任务？

Answer 1

答案很简单。 ContinueWith 是自动启动任务。第一个任务需要运行。

var r= Task<int>.Run<int>( () => 1 )
             .ContinueWith<int>( x => x.Result + 1 )
             .ContinueWith( x => Console.WriteLine( x.Result ) );

ContinueWith 返回从检查前一个任务开始的任务是否完成。此代码的工作方式与下面的代码相同

 var firstTask = new Task<int>( () => 1 );
        firstTask.Start();
        var firstawaiter = firstTask.GetAwaiter();
        var secondTask = new Task<int>( x => (int)x + 1 , firstawaiter.GetResult());

        firstawaiter.OnCompleted( () =>
        {
            secondTask.Start();
        } );

        var secondawaiter = secondTask.GetAwaiter();


        var thirdTask = new Task( x => Console.WriteLine( x ) , secondawaiter.GetResult());

        secondawaiter.OnCompleted( () =>
        {
            thirdTask.Start();
        } );

所以，如果第一个任务没有完成，下一个任务将不会开始。

而且你不需要开始 continuewith block 。

Answer 2

有什么理由不使用Task.Factory.StartNew^{msdn、ms docs} 来完成第一个任务？是的，它是不一致的 - 但它从根本上是一种不同的任务，就明确地开始而不是仅仅作为延续而言。

Answer 3

据我所知，没有明智的方法来组合框架提供的未启动任务。我能想到的最简单的解决方案是扩展方法。如果您需要此功能，可以在此基础上构建一些示例。

警告：就像传递和编写大量 lambdas 一样，如果您发现自己需要这些，这通常意味着您在设计中缺少一种可以简化代码的类型。问问自己通过创建子任务获得了什么。

/// <summary>
/// Compose tasks without starting them.
/// Waiting on the returned task waits for both components to complete.
/// An exception in the first task will stop the second task running.
/// </summary>
public static class TaskExtensions
{
    public static Task FollowedBy(this Task first, Task second)
    {
        return FollowedBy(first,
            () =>
            {
                second.Start();
                second.Wait();
            });
    }

    public static Task FollowedBy(this Task first, Action second)
    {
        return new Task(
            () =>
            {
                if (first.Status == TaskStatus.Created) first.Start();
                first.Wait();
                second();
            });
    }

    public static Task FollowedBy<T>(this Task first, Task<T> second)
    {
        return new Task<T>(
            () =>
            {
                if (first.Status == TaskStatus.Created) first.Start();
                first.Wait();
                second.Start();
                return second.Result;
            });
    }

    public static Task FollowedBy<T>(this Task<T> first, Action<T> second)
    {
        return new Task(
            () =>
            {
                if (first.Status == TaskStatus.Created) first.Start();
                var firstResult = first.Result;
                second(firstResult);
            });
    }

    public static Task<TSecond> FollowedBy<TFirst, TSecond>(this Task<TFirst> first, Func<TFirst, TSecond> second)
    {
        return new Task<TSecond>(
            () =>
            {
                if (first.Status == TaskStatus.Created) first.Start();
                return second(first.Result);
            });
    }
}

Answer 4

我今天也遇到了同样的问题。我想创建一个处理来自内部任务的错误的包装器任务。这是我想出的：

var yourInitialTask = new Task(delegate
{
    throw e;
});

var continuation = task.ContinueWith(t =>
{
    if (task.IsCanceled)
    {
        Debug.WriteLine("IsCanceled: " + job.GetType());
    }
    else if (task.IsFaulted)
    {
        Debug.WriteLine("IsFaulted: " + job.GetType());
    }
    else if (task.IsCompleted)
    {
        Debug.WriteLine("IsCompleted: " + job.GetType());
    }
}, TaskContinuationOptions.ExecuteSynchronously); //or consider removing execute synchronously if your continuation task is going to take long

var wrapper = new Task(() =>
{
   task.Start();
   continuation.Wait();
});

return wrapper;

这里的主要特点是 - 延续部分在原始任务之后运行，如您所愿 - 包装器是可启动的。使用ContineWith() 创建的后续任务不可启动。

这个例子的一个不太重要的特性是异常被记录和丢弃（解决了我的问题，而不是你的问题）。当 continuation 中发生异常时，您可能想要做一些不同的事情，例如将其作为当前任务的异常重新抛出，以便它冒泡。

Answer 5

问题在于使用 LINQ 选择任务只会创建一个表达式树！

所以这是你需要做的：

var query = 
    from i in Enumerable.Range(1, 4) 
    let task = Task.Factory.StartNew(() => Tuple.Create(i, IsPrime(i))) // put a breakpoint here
    select task.ContinueWith(delegate {
        Console.WriteLine("{0} {1} prime.", _.Result.Item1, _.Result.Item2 ? "is" : "is not");
    });
// breakpoint never hit yet
query.ToArray(); // breakpoint hit here 4 times
// all tasks are now running and continuations will start
TaskEx.Await(query.ToArray()); // breakpoint hit 4 more times!!

Answer 6

我不确定写这个有什么问题：

var t1 = new Task<int>(() => 1)
var r = from x in t1
        from y in new Task<int>(() => x + 1) 
        select y;
r.ContinueWith(x => Console.WriteLine(x.Result));
t1.Start();

或者这个：

var t = new Task<int>(() => 1)
t.ContinueWith(x => x.Result + 1)
 .ContinueWith(x => Console.WriteLine(x.Result))
t.Start();

这直接表达了你真正想做的事情。 （这是您要启动的初始任务。那么在该初始任务上调用 Start 有什么问题？）您为什么要寻找一种掩盖它的语法？

编辑：修复第一个示例...

编辑 2 以添加：

所以我现在意识到 LinqToTasks 期望任务选择器返回正在运行的任务。因此，您的第一个示例中的第二个 from 子句返回一个任务，该任务将永远不会运行。所以你真正需要的是这样的：

var t1 = new Task<int>(() => 1);
var r = from x in t1
        from y in Task<int>.Factory.StartNew(() => x + 1)
        select y;
r.ContinueWith(x => Console.WriteLine(x.Result));
t1.Start();

在这些from 子句中产生的任务上没有其他东西会调用Start。由于相关选择器直到前一个任务完成后才会真正执行，因此您仍然可以控制何时启动根任务。

这似乎可行，但它很丑陋。但这似乎是 LinqToTasks 的设计方式......我想我会坚持使用常规函数调用语法。