如何按顺序等待 C# 任务，而不是并行等待？

Question

我有一组在外部硬件上运行的异步测试。

我可以按顺序运行它们，但因为所有这些测试都有副作用，我希望能够对它们进行洗牌并一遍又一遍地运行它们。

当我将它们放在一个列表中并尝试在之后等待每个时，它们都并行运行，而不是 1 个运行。

我希望能够洗牌列表，然后按顺序运行它们。

我如何按顺序运行测试（ List<Task<bool> ），同时将它们保存在列表中，以便我可以随机播放列表？

private async void RunVisca()
{
    Ptz ptz = new Ptz(SelectedComPort, (byte)(1), SelectedBaudRate, Node.DeviceType.PTZ);

    UpdateResults("VISCA TEST START\n\n");

    // Method 1: Correct - Runs in order
    await VTestDriveClosedLoop(ptz, true);
    await VTestDriveClosedLoop(ptz, false);
    await VTestLimitsCl(ptz, 125, 20);
    await VTestLimitsOl(ptz, 125, 20);

    // Method 2: Incorrect - Runs in parallel
    List<Task<bool>> tests = new List<Task<bool>>();
    tests.Add(VTestDriveClosedLoop(ptz, true));
    tests.Add(VTestDriveClosedLoop(ptz, false));
    tests.Add(VTestLimitsCl(ptz, 125, 20));
    tests.Add(VTestLimitsOl(ptz, 125, 20));

    // Tasks all run in parallel here - should they not run in order?
    foreach(Task<bool> test in tests)
    {
        _ = await test.ConfigureAwait(true);
    }

    UpdateResults("\nTEST COMPLETE\n\n");
}

Answer 1

基于任务的异步模式 (TAP) 模式意味着调用返回Task的async方法将返回热任务。

一个处于热状态的Task已经启动。 这可以通过检查Task.Status属性来证明，它永远不会是TaskStatus.Created 。

冷任务将具有Task.Status属性， TaskStatus.Created只有在实例上调用Start()时才会开始运行。

创建冷任务的唯一方法是使用Task / Task<T>各自的公共构造函数。

---

由于您的任务是通过异步方法返回的，因此当它们返回给您时它们已经在运行。

要按顺序而不是并行运行它们，除非前一个任务已完成，否则您不能一个接一个地创建它们。 为确保这一点，您必须分别await它们。

这导致方法 1 是按顺序而不是并行运行热任务的正确方法。

await VTestDriveClosedLoop(ptz, true);
await VTestDriveClosedLoop(ptz, false);
await VTestLimitsCl(ptz, 125, 20);
await VTestLimitsOl(ptz, 125, 20);

---

方法 2/3 不正确，因为它将并行运行您的任务。

您正在将从async方法返回的热门任务添加到您的列表中，而无需等待它们。 在您继续将下一个任务添加到列表之前，它们将已经开始运行。

不等待第一个任务，因此无论任务 1 是否完成，第二个任务将立即开始。

不等待第二个任务，所以第三个任务等。

使用方法 2/3，它们将始终并行运行。

tests.Add(VTestDriveClosedLoop(ptz, true));
tests.Add(VTestDriveClosedLoop(ptz, false));

---

真正的问题是如何按顺序运行冷任务，以便我们可以将它们存储在列表中，同时利用延迟执行，直到我们遍历我们的列表。

解决方案是存储委托，这将触发以下任务构造函数：

public Task (Func<TResult> function);

这将创建冷任务，让您在调用Func<Task<bool>>时运行Task ：

var tests = new List<Func<Task<bool>>>();
tests.Add(() => VTestDriveClosedLoop(ptz, true));
tests.Add(() => VTestDriveClosedLoop(ptz, false));
tests.Add(() => VTestLimitsCl(ptz, 125, 20));
tests.Add(() => VTestLimitsOl(ptz, 125, 20));
    
foreach (var test in tests) {
     await test();
}

---

下面的演示程序将清楚地显示按顺序运行与并行运行的任务。

class Program
{
    private static async Task Main(string[] args)
    {
        // 1... 2... 3... 4...
        var tasksThatRunInOrder = new List<Func<Task<bool>>>();
        tasksThatRunInOrder.Add(() => Test("1"));
        tasksThatRunInOrder.Add(() => Test("2"));
        tasksThatRunInOrder.Add(() => Test("3"));
        tasksThatRunInOrder.Add(() => Test("4"));

        foreach (var test in tasksThatRunInOrder)
            await test();

        // 1, 2, 3, 4
        var testsThatRunInParallel = new List<Task<bool>>();
        testsThatRunInParallel.Add(Test("1"));
        testsThatRunInParallel.Add(Test("2"));
        testsThatRunInParallel.Add(Test("3"));
        testsThatRunInParallel.Add(Test("4"));

        foreach (var test in testsThatRunInParallel)
            await test;
    }

    private static async Task<bool> Test(string x)
    {
        Console.WriteLine(x);
        await Task.Delay(1000);
        return true;
    }
}

Answer 2

任务在创建时开始。 由于您是同时创建所有这些而不等待它们中的任何一个，因此它们将以不确定的并行方式执行。 我想也许您想改为存储代表。 这些在被调用之前不会执行。

var tests = new List<Func<Task<bool>>>();
tests.Add( () => VTestDriveClosedLoop(ptz, true) );
tests.Add( () => VTestDriveClosedLoop(ptz, false) );
tests.Add( () => VTestLimitsCl(ptz, 125, 20) );
tests.Add( () => VTestLimitsOl(ptz, 125, 20) );
    
foreach(var test in tests)
{
    _ = await test(); 
}

Answer 3

您可以创建一个列表，在其中随机化要运行的顺序，然后相应地调用创建任务的函数。 例如：

    static async Task RunTasks()
    {
        Random rng = new Random();
        var order = new List<int>() { 1, 2 };
        var shuffledOrder = order.OrderBy(a => rng.Next()).ToList();

        foreach (var i in shuffledOrder)
        {
            switch (i)
            {
            case 1:
                await LoadFile1();
                break;
            case 2:
                await LoadFile2();
                break;
            }
        }
    }

Answer 4

尝试在不分配给一次性变量的情况下等待。

Answer 5

ContinueWith调用链怎么样？

Task.Run(async () => 
{
    await VTestDriveClosedLoop(ptz, true);
}).ContinueWith(async (_) => 
{ 
    await VTestDriveClosedLoop(ptz, false);
}).ContinueWith(async (_) => 
{ 
    await VTestLimitsCl(ptz, 125, 20);
}).ContinueWith(async (_) => 
{ 
    await VTestLimitsOl(ptz, 125, 20);
});