CancellationTokenSource 类

定义

命名空间:: System.Threading

程序集:: mscorlib.dll, System.Threading.Tasks.dll

程序集:: mscorlib.dll

程序集:: System.Threading.Tasks.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

向 CancellationToken 应取消的信号。

public ref class CancellationTokenSource : IDisposable

public ref class CancellationTokenSource sealed : IDisposable

public class CancellationTokenSource : IDisposable

[System.Runtime.InteropServices.ComVisible(false)]
public sealed class CancellationTokenSource : IDisposable

[System.Runtime.InteropServices.ComVisible(false)]
public class CancellationTokenSource : IDisposable

type CancellationTokenSource = class
    interface IDisposable

[<System.Runtime.InteropServices.ComVisible(false)>]
type CancellationTokenSource = class
    interface IDisposable

Public Class CancellationTokenSource
Implements IDisposable

Public NotInheritable Class CancellationTokenSource
Implements IDisposable

继承: Object
CancellationTokenSource

属性: ComVisibleAttribute

实现: IDisposable

示例

以下示例使用随机数生成器模拟从 11 个不同的仪器读取 10 个整型值的数据收集应用程序。值为零表示一个检测的度量值已失败，在这种情况下，应取消操作，并且不应计算总体平均值。

为了处理操作的可能取消，该示例实例化一个 CancellationTokenSource 生成传递给 TaskFactory 对象的取消标记的对象。该 TaskFactory 对象反过来会将取消令牌传递给负责收集特定仪器读取的每个任务。 TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)调用该方法以确保仅在成功收集所有读数后计算平均值。如果任务尚未完成，因为它已被取消，则对方法的 TaskFactory.ContinueWhenAll 调用将引发异常。

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Define the cancellation token.
      CancellationTokenSource source = new CancellationTokenSource();
      CancellationToken token = source.Token;

      Random rnd = new Random();
      Object lockObj = new Object();
      
      List<Task<int[]>> tasks = new List<Task<int[]>>();
      TaskFactory factory = new TaskFactory(token);
      for (int taskCtr = 0; taskCtr <= 10; taskCtr++) {
         int iteration = taskCtr + 1;
         tasks.Add(factory.StartNew( () => {
           int value;
           int[] values = new int[10];
           for (int ctr = 1; ctr <= 10; ctr++) {
              lock (lockObj) {
                 value = rnd.Next(0,101);
              }
              if (value == 0) { 
                 source.Cancel();
                 Console.WriteLine("Cancelling at task {0}", iteration);
                 break;
              }   
              values[ctr-1] = value; 
           }
           return values;
        }, token));   
      }
      try {
         Task<double> fTask = factory.ContinueWhenAll(tasks.ToArray(), 
         (results) => {
            Console.WriteLine("Calculating overall mean...");
            long sum = 0;
            int n = 0; 
            foreach (var t in results) {
               foreach (var r in t.Result) {
                  sum += r;
                  n++;
               }
            }
            return sum/(double) n;
         } , token);
         Console.WriteLine("The mean is {0}.", fTask.Result);
      }   
      catch (AggregateException ae) {
         foreach (Exception e in ae.InnerExceptions) {
            if (e is TaskCanceledException)
               Console.WriteLine("Unable to compute mean: {0}", 
                  ((TaskCanceledException) e).Message);
            else
               Console.WriteLine("Exception: " + e.GetType().Name);
         }
      }
      finally {
         source.Dispose();
      }
   }
}
// Repeated execution of the example produces output like the following:
//       Cancelling at task 5
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 10
//       Unable to compute mean: A task was canceled.
//       
//       Calculating overall mean...
//       The mean is 5.29545454545455.
//       
//       Cancelling at task 4
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 5
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 6
//       Unable to compute mean: A task was canceled.
//       
//       Calculating overall mean...
//       The mean is 4.97363636363636.
//       
//       Cancelling at task 4
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 5
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 4
//       Unable to compute mean: A task was canceled.
//       
//       Calculating overall mean...
//       The mean is 4.86545454545455.

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Define the cancellation token.
      Dim source As New CancellationTokenSource()
      Dim token As CancellationToken = source.Token

      Dim lockObj As New Object()
      Dim rnd As New Random

      Dim tasks As New List(Of Task(Of Integer()))
      Dim factory As New TaskFactory(token)
      For taskCtr As Integer = 0 To 10
         Dim iteration As Integer = taskCtr + 1
         tasks.Add(factory.StartNew(Function()
                                       Dim value, values(9) As Integer
                                       For ctr As Integer = 1 To 10
                                          SyncLock lockObj
                                             value = rnd.Next(0,101)
                                          End SyncLock
                                          If value = 0 Then 
                                             source.Cancel
                                             Console.WriteLine("Cancelling at task {0}", iteration)
                                             Exit For
                                          End If   
                                          values(ctr-1) = value 
                                       Next
                                       Return values
                                    End Function, token))   
         
      Next
      Try
         Dim fTask As Task(Of Double) = factory.ContinueWhenAll(tasks.ToArray(), 
                                                         Function(results)
                                                            Console.WriteLine("Calculating overall mean...")
                                                            Dim sum As Long
                                                            Dim n As Integer 
                                                            For Each t In results
                                                               For Each r In t.Result
                                                                  sum += r
                                                                  n+= 1
                                                               Next
                                                            Next
                                                            Return sum/n
                                                         End Function, token)
         Console.WriteLine("The mean is {0}.", fTask.Result)
      Catch ae As AggregateException
         For Each e In ae.InnerExceptions
            If TypeOf e Is TaskCanceledException
               Console.WriteLine("Unable to compute mean: {0}", 
                                 CType(e, TaskCanceledException).Message)
            Else
               Console.WriteLine("Exception: " + e.GetType().Name)
            End If   
         Next
      Finally
         source.Dispose()
      End Try                                                          
   End Sub
End Module
' Repeated execution of the example produces output like the following:
'       Cancelling at task 5
'       Unable to compute mean: A task was canceled.
'       
'       Cancelling at task 10
'       Unable to compute mean: A task was canceled.
'       
'       Calculating overall mean...
'       The mean is 5.29545454545455.
'       
'       Cancelling at task 4
'       Unable to compute mean: A task was canceled.
'       
'       Cancelling at task 5
'       Unable to compute mean: A task was canceled.
'       
'       Cancelling at task 6
'       Unable to compute mean: A task was canceled.
'       
'       Calculating overall mean...
'       The mean is 4.97363636363636.
'       
'       Cancelling at task 4
'       Unable to compute mean: A task was canceled.
'       
'       Cancelling at task 5
'       Unable to compute mean: A task was canceled.
'       
'       Cancelling at task 4
'       Unable to compute mean: A task was canceled.
'       
'       Calculating overall mean...
'       The mean is 4.86545454545455.

注解

从 .NET Framework 4 开始，.NET Framework 使用统一模型来协作取消涉及两个对象的异步或长时间运行的同步操作：

一个 CancellationTokenSource 对象，它通过其 Token 属性提供取消令牌，并通过调用其 Cancel 或 CancelAfter 方法发送取消消息。
一个 CancellationToken 对象，指示是否请求取消。

实现协作取消模型的一般模式是：

实例化对象 CancellationTokenSource ，该对象管理取消通知并将其发送到单个取消令牌。
将 CancellationTokenSource.Token 属性返回的标记传递给每个侦听取消的任务或线程。
CancellationToken.IsCancellationRequested从接收取消令牌的操作中调用该方法。为每个任务或线程提供响应取消请求的机制。是否选择取消操作以及具体操作方式取决于应用程序逻辑。
CancellationTokenSource.Cancel调用该方法以提供取消通知。这会将 CancellationToken.IsCancellationRequested 取消令牌的每个副本的属性设置为 true。
Dispose使用完对象后CancellationTokenSource调用该方法。

有关详细信息，请参阅托管线程中的取消。

Important

此类型实现 IDisposable 接口。在使用完类型的实例后，应直接或间接释放类型。若要直接释放类型，请在块中Disposetry/调用其finally方法。若要间接释放它，请使用语言构造，例如 using （在 C# 中）或 Using （在 Visual Basic 中）。有关详细信息，请参阅接口主题中的 IDisposable “使用实现 IDisposable 的对象”部分。

构造函数

名称	说明
CancellationTokenSource()	初始化 CancellationTokenSource 类的新实例。
CancellationTokenSource(Int32)	初始化类的新实例，该实例 CancellationTokenSource 将在指定的延迟后取消（以毫秒为单位）。
CancellationTokenSource(TimeSpan)	初始化将在指定时间跨度后取消的类的新实例 CancellationTokenSource 。

属性

名称	说明
IsCancellationRequested	获取是否已为此 CancellationTokenSource请求取消。
Token	获取与此CancellationToken关联的值CancellationTokenSource。

方法

名称	说明
Cancel()	传达取消请求。
Cancel(Boolean)	传达取消请求，并指定在发生异常时是否应处理剩余回调和可取消操作。
CancelAfter(Int32)	在指定的毫秒数后计划对此 CancellationTokenSource 执行取消操作。
CancelAfter(TimeSpan)	在指定的时间跨度之后计划对此 CancellationTokenSource 执行取消操作。
CreateLinkedTokenSource(CancellationToken, CancellationToken)	创建一个在任一 CancellationTokenSource 源令牌处于已取消状态时处于已取消状态。
CreateLinkedTokenSource(CancellationToken[])	创建一个 CancellationTokenSource 在指定数组中的任何源令牌处于取消状态时处于取消状态。
Dispose()	释放类的 CancellationTokenSource 当前实例使用的所有资源。
Dispose(Boolean)	释放类使用 CancellationTokenSource 的非托管资源，并选择性地释放托管资源。
Equals(Object)	确定指定的对象是否等于当前对象。 (继承自 Object)
GetHashCode()	用作默认哈希函数。 (继承自 Object)
GetType()	获取当前实例的 Type。 (继承自 Object)
MemberwiseClone()	创建当前 Object的浅表副本。 (继承自 Object)
ToString()	返回一个表示当前对象的字符串。 (继承自 Object)

适用于

线程安全性

所有公共和受保护的成员 CancellationTokenSource 都是线程安全的，并且可以同时从多个线程使用，但例外，只有在 Dispose()对象上所有其他操作 CancellationTokenSource 都已完成时才能使用。

另请参阅

反馈

此页面是否有帮助？