如何启动异步任务对象

Question

我想同时开始收集Task 对象并等到所有对象都完成。以下代码显示了我想要的行为。

public class Program
{
    class TaskTest
    {
        private Task createPauseTask(int ms)
        {
            // works well
            return Task.Run(async () =>
            // subsitution: return new Task(async () =>
            {
                Console.WriteLine($"Start {ms} ms pause");
                await Task.Delay(ms);
                Console.WriteLine($"{ms} ms are elapsed");
            });
        }

        public async Task Start()
        {
            var taskList= new List<Task>(new[]
            {
                createPauseTask(1000),
                createPauseTask(2000)
            });
            // taskList.ForEach(x => x.Start());
            await Task.WhenAll(taskList);
            Console.WriteLine("------------");
        }
    }

    public static void Main()
    {
        var t = new TaskTest();
        Task.Run(() => t.Start());
        Console.ReadKey();
    }
}

输出是：

Start 1000 ms pause
Start 2000 ms pause
1000 ms are elapsed
2000 ms are elapsed
------------

现在我想知道是否可以准备我的任务并单独启动它们。为此，我将createPauseTask(int ms)method 中的第一行从return Task.Run(async () => 更改为return new Task(async () =>

在Start() 方法中，我在WhenAll 之前添加了taskList.ForEach(x => x.Start());。但随后可怕的事情发生了。 WhenAll 调用立即完成，输出为：

Start 2000 ms pause
Start 1000 ms pause    
------------    
1000 ms are elapsed
2000 ms are elapsed

谁能告诉我我的错误是什么以及如何解决它？

Answer 1

问题是您使用的Task 构造函数接受Action 委托。当你说

var task = new Task(async () => { /* Do things */ });

你不是在创建一个“做事”的任务；相反，您会创建一个任务，该任务执行返回任务的操作，而该（内部）任务就是“做事”。创建这个（内部）任务非常快，因为代理在第一个await 处返回Task，并且几乎立即完成。由于委托是 Action，因此生成的 Task 被有效地丢弃，现在不能再用于等待。

当您在外部任务上调用await Task.WhenAll(tasks) 时，您只是在等待内部任务被创建（几乎立即）。之后内部任务继续运行。

有构造函数覆盖可以让你做你想做的事，但是你的语法会有点麻烦，就像 Paulo 的回答一样：

public static Task<Task> CreatePauseTask(int ms)
{
    return new Task<Task>(async () =>
        {
            Console.WriteLine($"Start {ms} ms pause");
            await Task.Delay(ms);
            Console.WriteLine($"{ms} ms are elapsed");
        });
}

您现在有一个执行相同操作的任务，但这次返回内部Task。要等待内部任务，您可以这样做：

await Task.WhenAll(await Task.WhenAll(taskList));

内部等待返回内部任务列表，外部等待等待它们。

---

正如也提到的，虽然 - 使用构造函数创建未启动的任务是一个领域，只有当你有一个高度特定的要求时，你才应该在其中使用Task.Run() 或简单地调用任务返回方法的更标准做法确实如此不符合要求（99.99% 的情况下都会这样做）。

大多数 Task 构造函数是在 async-await 存在之前创建的，并且可能只是由于遗留原因而仍然存在。

---

编辑：查看 2 个委托的签名可能也有帮助，C# lambda 表示法允许我们（通常很方便地）忽略这些签名。

对于new Task(async () => { /* Do things */ })，我们有

async void Action() { }

（void 是这里的主要问题）。

对于new Task<Task>(async () => { /* Do things */ })，我们有

async Task Function() { }

两个 lambda 在语法上相同，但在语义上不同。

Answer 2

我不知道你为什么会被Task.Run找到。只是不需要在您的代码中每次使用它。

我还想知道您在哪里读到使用 Task 构造函数是推荐的做法。

无论如何，如果不使用 Task 构造函数，将会是这样的：

class TaskTest
{
    private async Task CreatePauseTask(int ms)
    {
        Console.WriteLine($"Start {ms} ms pause");
        await Task.Delay(ms);
        Console.WriteLine($"{ms} ms are elapsed");
    }

    public async Task Start()
    {
        var taskList = new List<Task>(new[]
        {
                CreatePauseTask(1000),
                CreatePauseTask(2000)
            });
        await Task.WhenAll(taskList);
        Console.WriteLine("------------");
    }
}


static void Main()
{
    var t = new TaskTest();
    t.Start();
    Console.ReadKey();
}

然后输出：

Start 1000 ms pause
Start 2000 ms pause
1000 ms are elapsed
2000 ms are elapsed
------------

使用Task 构造函数将是：

class TaskTest
{
    private Task CreatePauseTask(int ms)
    {
        return new Task<Task>(async () =>
        {
            Console.WriteLine($"Start {ms} ms pause");
            await Task.Delay(ms);
            Console.WriteLine($"{ms} ms are elapsed");
        }, TaskCreationOptions.DenyChildAttach);
    }

    public async Task Start()
    {
        var taskList = new List<Task>(new[]
        {
                CreatePauseTask(1000),
                CreatePauseTask(2000)
            });
        taskList.ForEach(t => t.Start(TaskScheduler.Default));
        await Task.WhenAll(taskList);
        Console.WriteLine("------------");
    }
}


static void Main()
{
    var t = new TaskTest();
    t.Start();
    Console.ReadKey();
}

然后输出：

Start 1000 ms pause
Start 2000 ms pause
------------
1000 ms are elapsed
2000 ms are elapsed

这里的问题是Task.Run 理解Task 返回函数而Task 构造函数不理解。因此，使用Task 构造函数将调用将在第一次阻塞等待时返回的函数（await Task.Delay(ms);）。

这是预期的行为。