C# 在进行长时间运行的操作之前，是否立即取消操作？

我正在使用AsParallel，并以以下方式结合了并行度和取消

AsParallel().WithCancellation(cs.Token).WithDegreeOfParallelism(2)

这是我的理解。一次只处理两个传入序列。一旦一个请求完成，就会处理更多的项目。但是，如果取消 启动请求后，将处理传入队列中尚未提取的项目。基于这种理解，我创建了以下代码

class Employee
    {
        public int ID { get; set;}
        public string FirstName { get; set;}
        public string LastName { get; set;}
    }

    class Program
    {

        private static List<Employee> _Employees;
        static CancellationTokenSource cs = new CancellationTokenSource();
        static Random rand = new Random();

        static void Main(string[] args)
        {
            _Employees = new List<Employee>() 
            {
                new Employee() { ID = 1, FirstName = "John", LastName = "Doe" },
                new Employee() { ID = 2, FirstName = "Peter", LastName = "Saul" },
                new Employee() { ID = 3, FirstName = "Mike", LastName = "Sue" },
                new Employee() { ID = 4, FirstName = "Catherina", LastName = "Desoza" },
                new Employee() { ID = 5, FirstName = "Paul", LastName = "Smith" },
                new Employee() { ID = 6, FirstName = "Paul2", LastName = "Smith" },
                new Employee() { ID = 7, FirstName = "Paul3", LastName = "Smith" },
                new Employee() { ID = 8, FirstName = "Paul4", LastName = "Smith" },
                new Employee() { ID = 9, FirstName = "Paul5", LastName = "Smith" },
                new Employee() { ID = 10, FirstName = "Paul6", LastName = "Smith" },
                new Employee() { ID = 5, FirstName = "Paul7", LastName = "Smith" }
            };

            try
            {
                var tasks = _Employees.AsParallel().WithCancellation(cs.Token).WithDegreeOfParallelism(2).Select(x => ProcessThisEmployee(x, cs.Token)).ToArray();
                Console.WriteLine("Now waiting");
                Thread.Sleep(1000);
                cs.Cancel();
                Task.WaitAll(tasks);
            }
            catch (AggregateException ae)
            {
                // error handling code
                Console.WriteLine("something bad happened");
            }
            catch (Exception ex)
            {
                // error handling code
                Console.WriteLine("something even worst happened");
            }
            // other stuff
            Console.WriteLine("All Done");
        }

        private static async Task ProcessThisEmployee(Employee x, CancellationToken token)
        {
            if (token.IsCancellationRequested)
            {
                Console.WriteLine(string.Format("ThreadID = {0} -> Employee {1} -> Cancelled", System.Threading.Thread.CurrentThread.ManagedThreadId));
                return;
            }
            int Sleep = rand.Next(800, 2000);
            Console.WriteLine(string.Format("ThreadID = {0} -> Employee {1} -> Sleeping for {2}", System.Threading.Thread.CurrentThread.ManagedThreadId, x.ID, Sleep));
            await TaskEx.Run(() => System.Threading.Thread.Sleep(Sleep));

            Console.WriteLine(string.Format("ThreadID = {0} -> Employee {1} finished", System.Threading.Thread.CurrentThread.ManagedThreadId, x.ID));
        }

    }

然后我改变了流程ThisEmployee，基本上在睡眠后移动了token.IsCancellationRequested消息，如下所示

private static async Task ProcessThisEmployee(Employee x, CancellationToken token)
{

    int Sleep = rand.Next(800, 2000);
    Console.WriteLine(string.Format("ThreadID = {0} -> Employee {1} -> Sleeping for {2}", System.Threading.Thread.CurrentThread.ManagedThreadId, x.ID, Sleep));
    await TaskEx.Run(() => System.Threading.Thread.Sleep(Sleep));
    if (token.IsCancellationRequested)
    {
        Console.WriteLine(string.Format("ThreadID = {0} -> Employee {1} -> Cancelled", System.Threading.Thread.CurrentThread.ManagedThreadId));
        return;
    }
    Console.WriteLine(string.Format("ThreadID = {0} -> Employee {1} finished", System.Threading.Thread.CurrentThread.ManagedThreadId, x.ID));
}

现在我得到以下输出

ThreadID = 3 -> Employee 1 -> Sleeping for 1330  
ThreadID = 1 -> Employee 7 -> Sleeping for 1868  
ThreadID = 3 -> Employee 2 -> Sleeping for 903  
ThreadID = 3 -> Employee 3 -> Sleeping for 1241  
ThreadID = 3 -> Employee 4 -> Sleeping for 1367  
ThreadID = 3 -> Employee 5 -> Sleeping for 1007  
ThreadID = 3 -> Employee 6 -> Sleeping for 923  
ThreadID = 1 -> Employee 8 -> Sleeping for 1032  
ThreadID = 1 -> Employee 9 -> Sleeping for 1948  
ThreadID = 1 -> Employee 10 -> Sleeping for 1456  
ThreadID = 1 -> Employee 5 -> Sleeping for 1737  
Now waiting  
ThreadID = 5 -> Employee 2 finished  
ThreadID = 3 -> Employee 6 finished  
something bad happened  
All Done  

---

我的问题是我对这个工作流程有什么误解。我基本上希望在不进行长时间运行操作的情况下尽快取消该操作（在这种情况下，睡眠只是一个示例，但它可能非常昂贵）

该代码存在一些问题：

1.

ToArray（）

具体化序列，即只有在源序列的所有输入都通过

选择（…）

后，它才会返回

由于在此之后调用了

cs.Cancel（）

，因此它不会在

过程开始时立即触发
令牌.IsCancellationRequested

2.
WithDegreeOfParallelism（2）.选择（x=>ProcessThisEmployee（x，cs.Token））
看起来不错，但实际上并没有达到您想要的效果，因为
ProcessThisEmployee
是一个异步方法，在到达第一次返回或第一次等待时立即返回

您可能想做的是执行长时间运行的
ProcessThisEmployee
方法，只需2个并行度。实际上，您要做的是创建一组仅具有2度并行性的
任务。在此之后，任务本身都会并发运行

我不知道如何解决你的特殊情况，因为我不知道上下文。但也许这已经对你有所帮助了


更新以回复您的评论：我正在做ToArray and ProcessThisEmployee是一个异步方法，因为此代码将成为库的一部分，并且可以从WPF应用程序中使用。最终用户可能希望在UI上提供更新，所以在操作完成之前我不想阻止（john smith）

不要为本质上不是异步的东西编写异步包装器，即主要是文件、网络或数据库访问。如果使用库的开发人员希望在异步上下文中调用某些东西，他仍然可以执行
等待任务。运行（…）
。有关这方面的更多信息，您可以查看这篇文章，了解您是否需要

在我看来，如果您已经有了一个正在工作的LINQ查询，并且希望加快它的速度，那么PLINQ最有用，因为该查询将适合于并行处理

在您的情况下，最简单的方法可能是使用2个线程的工作队列。我很确定在web上有这样的例子。
我正在做的是Array and ProcessThisEmployee是一个异步方法，因为此代码将成为库的一部分，并且可以从WPF应用程序中使用。最终用户可能希望在UI上提供更新，所以在操作完成之前我不想阻止
ThreadID = 3 -> Employee 1 -> Sleeping for 1330  
ThreadID = 1 -> Employee 7 -> Sleeping for 1868  
ThreadID = 3 -> Employee 2 -> Sleeping for 903  
ThreadID = 3 -> Employee 3 -> Sleeping for 1241  
ThreadID = 3 -> Employee 4 -> Sleeping for 1367  
ThreadID = 3 -> Employee 5 -> Sleeping for 1007  
ThreadID = 3 -> Employee 6 -> Sleeping for 923  
ThreadID = 1 -> Employee 8 -> Sleeping for 1032  
ThreadID = 1 -> Employee 9 -> Sleeping for 1948  
ThreadID = 1 -> Employee 10 -> Sleeping for 1456  
ThreadID = 1 -> Employee 5 -> Sleeping for 1737  
Now waiting  
ThreadID = 5 -> Employee 2 finished  
ThreadID = 3 -> Employee 6 finished  
something bad happened  
All Done