CancellationTokenSource CancellationTokenSource CancellationTokenSource CancellationTokenSource Class

定义

通知 CancellationToken,告知其应被取消。Signals to a CancellationToken that it should be canceled.

public ref class CancellationTokenSource : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class CancellationTokenSource : IDisposable
type CancellationTokenSource = class
    interface IDisposable
Public Class CancellationTokenSource
Implements IDisposable
继承
CancellationTokenSourceCancellationTokenSourceCancellationTokenSourceCancellationTokenSource
属性
实现

示例

下面的示例使用随机数生成器来模拟数据收集应用程序, 该应用程序从第11个不同乐器读取10个整数值。The following example uses a random number generator to emulate a data collection application that reads 10 integral values from eleven different instruments. 如果值为零, 则指示度量值对一个检测失败, 在这种情况下, 应取消该操作, 而不应计算整体平均值。A value of zero indicates that the measurement has failed for one instrument, in which case the operation should be cancelled and no overall mean should be computed.

为了处理可能取消的操作, 此示例实例化一个CancellationTokenSource对象, 该对象生成一个传递TaskFactory给对象的取消标记。To handle the possible cancellation of the operation, the example instantiates a CancellationTokenSource object that generates a cancellation token which is passed to a TaskFactory object. TaskFactory对象反过来将取消标记传递给负责收集特定检测的读取的每个任务。The TaskFactory object in turn passes the cancellation token to each of the tasks responsible for collecting readings for a particular instrument. 调用TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)方法以确保仅在成功收集所有读数后计算平均值。The TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) method is called to ensure that the mean is computed only after all readings have been gathered successfully. 如果任务未被取消, 则调用TaskFactory.ContinueWhenAll方法将引发异常。If a task has not because it has been cancelled, the call to the TaskFactory.ContinueWhenAll method throws an exception.

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 使用统一的模型来协作取消涉及两个对象的异步操作或长时间运行的同步操作: .NET Framework 4.NET Framework 4Starting with the .NET Framework 4.NET Framework 4, the .NET Framework uses a unified model for cooperative cancellation of asynchronous or long-running synchronous operations that involves two objects:

用于实现协作取消模型的常规模式是:The general pattern for implementing the cooperative cancellation model is:

有关详细信息,请参阅托管线程中的取消For more information, see Cancellation in Managed Threads.

重要

此类型实现IDisposable接口。This type implements the IDisposable interface. 使用完该类型的实例后, 应直接或间接释放该实例。When you have finished using an instance of the type, you should dispose of it either directly or indirectly. 若要直接Dispose释放类型, 请try / catch在块中调用其方法。To dispose of the type directly, call its Dispose method in a try/catch block. 若要间接释放类型,请使用 using(在 C# 中)或 Using(在 Visual Basic 中)等语言构造。To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). 有关详细信息, 请参阅IDisposable接口主题中的 "使用实现 IDisposable 的对象" 一节。For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

构造函数

CancellationTokenSource() CancellationTokenSource() CancellationTokenSource() CancellationTokenSource()

初始化 CancellationTokenSource 类的新实例。Initializes a new instance of the CancellationTokenSource class.

CancellationTokenSource(Int32) CancellationTokenSource(Int32) CancellationTokenSource(Int32) CancellationTokenSource(Int32)

初始化 CancellationTokenSource 类的新实例,在指定的延迟(以毫秒为单位)后将被取消。Initializes a new instance of the CancellationTokenSource class that will be canceled after the specified delay in milliseconds.

CancellationTokenSource(TimeSpan) CancellationTokenSource(TimeSpan) CancellationTokenSource(TimeSpan) CancellationTokenSource(TimeSpan)

初始化 CancellationTokenSource 类的新实例,在指定的时间跨度后将被取消。Initializes a new instance of the CancellationTokenSource class that will be canceled after the specified time span.

属性

IsCancellationRequested IsCancellationRequested IsCancellationRequested IsCancellationRequested

获取是否已请求取消此 CancellationTokenSourceGets whether cancellation has been requested for this CancellationTokenSource.

Token Token Token Token

获取与此 CancellationToken 关联的 CancellationTokenSourceGets the CancellationToken associated with this CancellationTokenSource.

方法

Cancel() Cancel() Cancel() Cancel()

传达取消请求。Communicates a request for cancellation.

Cancel(Boolean) Cancel(Boolean) Cancel(Boolean) Cancel(Boolean)

如果出现异常,传达取消请求,并指定是否应处理其余回调和可取消操作。Communicates a request for cancellation, and specifies whether remaining callbacks and cancelable operations should be processed if an exception occurs.

CancelAfter(Int32) CancelAfter(Int32) CancelAfter(Int32) CancelAfter(Int32)

在指定的毫秒数后计划对此 CancellationTokenSource 的取消操作。Schedules a cancel operation on this CancellationTokenSource after the specified number of milliseconds.

CancelAfter(TimeSpan) CancelAfter(TimeSpan) CancelAfter(TimeSpan) CancelAfter(TimeSpan)

在指定的时间跨度后计划对此 CancellationTokenSource 的取消操作。Schedules a cancel operation on this CancellationTokenSource after the specified time span.

CreateLinkedTokenSource(CancellationToken, CancellationToken) CreateLinkedTokenSource(CancellationToken, CancellationToken) CreateLinkedTokenSource(CancellationToken, CancellationToken) CreateLinkedTokenSource(CancellationToken, CancellationToken)

创建一个将在任何源标记处于取消状态时处于取消状态的 CancellationTokenSourceCreates a CancellationTokenSource that will be in the canceled state when any of the source tokens are in the canceled state.

CreateLinkedTokenSource(CancellationToken[]) CreateLinkedTokenSource(CancellationToken[]) CreateLinkedTokenSource(CancellationToken[]) CreateLinkedTokenSource(CancellationToken[])

创建一个将在在指定的数组中任何源标记处于取消状态时处于取消状态的 CancellationTokenSourceCreates a CancellationTokenSource that will be in the canceled state when any of the source tokens in the specified array are in the canceled state.

Dispose() Dispose() Dispose() Dispose()

释放 CancellationTokenSource 类的当前实例所使用的所有资源。Releases all resources used by the current instance of the CancellationTokenSource class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

释放 CancellationTokenSource 类使用的非托管资源,并可以选择释放托管资源。Releases the unmanaged resources used by the CancellationTokenSource class and optionally releases the managed resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

确定指定的对象是否等于当前对象。Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

作为默认哈希函数。Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

获取当前实例的 TypeGets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

创建当前 Object 的浅表副本。Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

返回表示当前对象的字符串。Returns a string that represents the current object.

(Inherited from Object)

适用于

线程安全性

的所有公共和受保护CancellationTokenSource的成员都是线程安全的, 并且可以从多个线程并发使用, Dispose()但除外, 只能在对象上的CancellationTokenSource所有其他操作都完成时使用。All public and protected members of CancellationTokenSource are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose(), which must only be used when all other operations on the CancellationTokenSource object have completed.

另请参阅