C# 暂停异步任务适用于一种方法，但不适用于另一种方法

Question

我有一个名为 PauseOrCancelToken 的 class，它是由另一个 class 创建的，PauseOrCancelTokenSource。 PauseOrCancelToken 基本上封装了从这个 MSDN 博客 post 实现的 CancellationToken 和 PauseToken：https://blogs.msdn.microsoft.com/pfxteam/2013/01/13/cooperatively-pausing-async-methods/

我已经对其进行了测试，在一个简单的示例用例中（我将要 post 的代码中的方法 A），它按预期工作。

但是，当我使用我打算在生产中使用的重要代码 (MethodB/ProxyTester.Start()) 对其进行测试时，它不会暂停异步任务。

public partial class PauseCancelForm : Form
{

    private PauseOrCancelTokenSource pcts = new PauseOrCancelTokenSource();

    public PauseCancelForm()
    {
        InitializeComponent();
    }

    private void StartButton_Click(object sender, EventArgs e)
    {
        Task.Run(() =>
        {
            MethodA(pcts.Token).Wait();
        });
    }

    private async Task MethodA(PauseOrCancelToken pct)
    {
        //Pauses as intended when the pause button is clicked.
        for (int i = 0; i < 10000; i++)
        {
            Console.WriteLine(i);
            await Task.Delay(1000);
            await pct.PauseOrCancelIfRequested();
        }
    }

    private async Task MethodB(PauseOrCancelToken pct)
    {
        //Doesn't pause.
        var proxies = new List<Proxy>();
        var judges = new List<ProxyJudge>();
        for (int i = 0; i < 10000; i++)
        {
            proxies.Add(new Proxy("127.0.0." + RandomUtility.GetRandomInt(1, 100), 8888));
        }

        judges.Add(new ProxyJudge("http://azenv.net"));

        await ProxyTester.Start(proxies, judges, pct);
    }

    private void PauseButton_Click(object sender, EventArgs e)
    {
        pcts.Pause();
    }

    private void StopButton_Click(object sender, EventArgs e)
    {
        pcts.Cancel();
    }

    private void ResumeButton_Click(object sender, EventArgs e)
    {
        pcts.Resume();
    }
}

public class PauseOrCancelTokenSource
{

    private PauseTokenSource pts = new PauseTokenSource();
    private CancellationTokenSource cts = new CancellationTokenSource();
    public PauseOrCancelToken Token { get { return new PauseOrCancelToken(pts, cts); } }

    public void Pause()
    {
        pts.IsPaused = true;
    }

    public void Resume()
    {
        pts.IsPaused = false;
    }

    public void Cancel()
    {
        cts.Cancel();
    }
}

public class PauseOrCancelToken
{
    private PauseToken pt;
    private CancellationToken ct;

    public PauseOrCancelToken(PauseTokenSource pts, CancellationTokenSource cts)
    {
        this.pt = pts.Token;
        this.ct = cts.Token;
    }

    public async Task PauseIfRequested()
    {
        await pt.WaitWhilePausedAsync();
    }

    public void CancelIfRequested()
    {
        ct.ThrowIfCancellationRequested();
    }

    public async Task PauseOrCancelIfRequested()
    {
        await PauseIfRequested();
        CancelIfRequested();
    }
}

public class ProxyTester
{

    public async static Task Start(List<Proxy> proxies, List<ProxyJudge> judges, PauseOrCancelToken pct, List<ProxyTest> tests = null)
    {
        if (tests == null)
        {
            tests = new List<ProxyTest>();
        }

        //Get external IP to check if proxy is anonymous.
        var publicIp = await WebUtility.GetPublicIP();

        //Validate proxy judges.
        var tasks = new List<Task>();
        foreach (var judge in judges)
        {
            tasks.Add(Task.Run(async () => {
                judge.IsValid = await judge.TestValidityAsync();
                await pct.PauseOrCancelIfRequested();
            }));
        }

        await Task.WhenAll(tasks);

        var validJudges = from judge in judges
                            where judge.IsValid
                            select judge;

        if (validJudges.Count() == 0)
        {
            throw new Exception("No valid judges loaded.");
        }

        //Validate proxy tests.
        tasks.Clear();
        foreach (var test in tests)
        {
            tasks.Add(Task.Run(async () => {
                test.IsValid = await test.TestValidityAsync();
                await pct.PauseOrCancelIfRequested();
            }));
        }

        await Task.WhenAll(tasks);

        var validTests = from test in tests
                            where test.IsValid
                            select test;

        var count = 0;
        //Test proxies with a random, valid proxy judge.  If valid, test with all valid proxy tests.
        tasks.Clear();
        foreach (var proxy in proxies)
        {
            tasks.Add(Task.Run(async () =>
            {
                proxy.IsValid = await proxy.TestValidityAsync(validJudges.ElementAt(RandomUtility.GetRandomInt(0, validJudges.Count())));
                count++;
                Console.WriteLine(count);
                await pct.PauseOrCancelIfRequested();

                if (proxy.IsValid)
                {
                    proxy.TestedSites.AddRange(validTests);
                    var childTasks = new List<Task>();
                    foreach (var test in validTests)
                    {
                        childTasks.Add(Task.Run(async () =>
                        {
                            proxy.TestedSites.ElementAt(proxy.TestedSites.IndexOf(test)).IsValid = await proxy.TestValidityAsync(test);
                            await pct.PauseOrCancelIfRequested();
                        }));
                    }

                    await Task.WhenAll(childTasks);
                }
            }));
        }


        await Task.WhenAll(tasks);

    }
}

Answer 1

通常，ProxyTester.Start 中的代码以这种方式使用暂停令牌：

foreach (var judge in judges)
{
    tasks.Add(Task.Run(async () => {
        judge.IsValid = await judge.TestValidityAsync();
        await pct.PauseOrCancelIfRequested();
    }));
}

这运行s judges.Length个任务。暂停令牌时会发生什么？好吧，实际上没什么用。所有任务持续到运行，他们都将完成他们有用的工作（await judge.TestValidityAsync()）。然后，当所有有用的工作都完成后，它们应该就完成了——它们将在 await pct.PauseOrCancelIfRequested() 处暂停。我怀疑这是你想要的结果。更改顺序不会有太大帮助。

将其与 "working" 示例进行比较：

for (int i = 0; i < 10000; i++)
{
    Console.WriteLine(i);
    await Task.Delay(1000);
    await pct.PauseOrCancelIfRequested();
}

这里的执行是顺序的（而不是像上面那样并行的）并且你每次迭代都检查暂停标记，所以它按预期工作。

如果您希望能够在现实世界场景中暂停 - 不要一次开始所有这些任务，运行分批进行（使用 SemaphoreSlim 或类似技术），并且每批后检查暂停令牌。

C# 暂停异步任务适用于一种方法，但不适用于另一种方法

C# Pausing Async Task works in one method, but not another

.net

c#

task

task-parallel-library