Task extension methods for executing in series/sequence.

TaskExtensions.cs

public static class TaskExtensions
{
    /// <summary>
    ///     Executes the next task after the completion of the first.
    /// </summary>
    /// <param name="first">Currently executing task.</param>
    /// <param name="next">Function returning the task to execute next.</param>
    /// <returns>The next task instance.</returns>
    public static Task Then(this Task first, Func<Task> next)
    {
        if (first == null) throw new ArgumentNullException(nameof(first));

        if (next == null) throw new ArgumentNullException(nameof(next));

        var tcs = new TaskCompletionSource<object>();
        first.ContinueWith(delegate
        {
            if (first.IsFaulted && first.Exception != null)
                tcs.TrySetException(first.Exception.InnerExceptions);
            else if (first.IsCanceled) tcs.TrySetCanceled();
            else
                try
                {
                    var t = next();
                    if (t == null) tcs.TrySetCanceled();
                    else
                        t.ContinueWith(delegate
                        {
                            if (t.IsFaulted && t.Exception != null)
                                tcs.TrySetException(t.Exception.InnerExceptions);
                            else if (t.IsCanceled) tcs.TrySetCanceled();
                            else tcs.TrySetResult(null);
                        }, TaskContinuationOptions.ExecuteSynchronously);
                }
                catch (Exception exc)
                {
                    tcs.TrySetException(exc);
                }
        }, TaskContinuationOptions.ExecuteSynchronously);
        return tcs.Task;
    }

    /// <summary>
    ///     Executes the params array of tasks in sequence.
    /// </summary>
    /// <param name="actions">
    ///     Destructured array of functions
    ///     that return the tasks to execute.
    /// </param>
    /// <returns>The final task instance.</returns>
    public static Task Sequence(params Func<Task>[] actions)
    {
        Task last = null;
        foreach (var action in actions)
            last = last == null ? Task.Factory.StartNew(action).Unwrap() : last.Then(action);
        return last;
    }
}