Использование TPL для создания последовательного порядка действий с помощью предложения continueWith

Первоначальная проблема заключается в том, что вы создаете две задачи, но ожидаете только одну.

// t is the "first" task
var t = Task.Factory.StartNew(() => DoSomeWork(token));
// the continuation task is not assigned
t.ContinueWith((prevTask) => DoSomeWork(token));
Task.WaitAll(t); // <-- wait only on "t", which is the first task
Console.WriteLine("Finish"); // when the first task finishes, this gets printed
// now the continuation task is executing, but you are not waiting for it

Что происходит во втором фрагменте, так это то, что вы ожидаете задачи продолжения, поэтому она будет ждать, пока она не завершится.

// t is now the continuation task
var t = Task.Factory.StartNew(() => DoSomeWork(token))
             .ContinueWith((prevTask) => DoSomeWork(token));
Task.WaitAll(t); // <-- wait till the continuation task has finished

Итак, второй метод в порядке, но если вы хотите более тонкое управление, просто назначьте переменную задачи для ожидания продолжения задачи:

// t is the "first" task
var t = Task.Factory.StartNew(() => DoSomeWork(token));
// The continuation task is assigned to "t2"
var t2 = t.ContinueWith((prevTask) => DoSomeWork(token));
Task.WaitAll(new [] { t, t2 } ); // <-- wait for all tasks
Console.WriteLine("Finish");

Примечание. Я следовал вашему коду в примерах, но WaitAll не принимает ни одной задачи в качестве параметра (он принимает массив задач), поэтому, вероятно, не компилируется. Вы либо используете Task.Wait, либо передаете массив WaitAll

Правильный способ асинхронного кодирования на C# — использовать ключевое слово await.

public async Task DoLotsOfWork()
{
    await DoSomeWorkAsync();
    await DoSomeMoreWorkAsync();
    Console.WriteLine("Finish");
}

У вас будут некоторые проблемы с запуском этого кода из консольного приложения, поэтому я бы посоветовал вам использовать библиотеку Task.AsyncEx @StephenCleary.

https://www.nuget.org/packages/Nito.AsyncEx/

Вы используете это так.

public void Main()
{
    AsyncContext.Run(DoLotsOfWork);
}

В дальнейшем. Существует очень мало причин для использования методов Task.Run (или, что еще хуже, Task.Factory.StartNew). Они запускают ваш метод в фоновом режиме как часть работы Threadpool.

Например

private static async Task DoSomeWorkAsync(CancellationToken ct)
{
    await Task.Delay(TimeSpan.FromMilliseconds(1000), ct);
    Console.WriteLine(id++);
}

Это НЕ будет работать ни в одном потоке (таким образом, не блокируя ни один поток). Вместо этого создается таймер/обратный вызов, чтобы основной поток возвращался ко второй строке через 1000 миллисекунд.

РЕДАКТИРОВАТЬ: сделать это динамически также довольно просто

public async Task DoLotsOfWork(IEnumerable<Func<Task>> tasks)
{
    foreach(var task in tasks)
        await task();
    Console.WriteLine("Finished");
}

Однако, если вы спросите о методах, которые используют ужасный шаблон EAP, я бы посоветовал вам использовать вспомогательную функцию Rx Observable.FromEventPattern.

public async Task SendEmail(MailMessage message)
{
    using(var smtp = new SmtpClient())
    {
        smtp.SendAsync(message);
        await Observable.FromEventPattern<>(x => smtp.SendCompleted +=x, x => smtp.SendCompleted -=x)
                  .ToTask()
    }
}

Дальнейшее РЕДАКТИРОВАТЬ:

public class Publisher
{
    public IObservable<CancelationToken> SomeEvent {get;}
}

public abstract class Subscriber
{
    public abstract IObservable<CancelationToken> Subscribe(IObservable<CancelationToken> observable);

}

IEnumerable<Subscriber> subscribers = ...
Publisher publisher = ...

IDisposable subscription = subscribers.Aggregate(publisher.SomeEvent, (e, sub) => sub.Subscribe(e)).Subscribe();

//Dispose the subscription when you want to stop listening.