CancellationTokenSource クラス

定義

取り消す必要があることを 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
継承
CancellationTokenSource
属性
実装

次の例では、乱数ジェネレーターを使用して、11 個の異なる計測器から 10 個の整数値を読み取るデータ収集アプリケーションをエミュレートします。 0 の値は、測定が 1 つの計測器に対して失敗したことを示します。その場合、操作を取り消し、全体的な平均を計算する必要はありません。

操作のキャンセルの可能性を処理するために、この例では、オブジェクトに渡されるキャンセル トークンを生成するオブジェクトをTaskFactoryインスタンス化CancellationTokenSourceします。 オブジェクトは 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では、2 つのオブジェクトを含む非同期または実行時間の長い同期操作を協調的に取り消す統合モデルが使用されます。

  • CancellationTokenSourceプロパティを通じてキャンセル トークンを提供し、そのTokenオブジェクトまたはCancelAfterメソッドを呼び出してキャンセル メッセージをCancel送信するオブジェクト。

  • CancellationToken取り消しが要求されるかどうかを示すオブジェクト。

連携によるキャンセル処理モデルを実装するための一般的なパターンは次のとおりです。

  • CancellationTokenSource オブジェクトのインスタンスを作成します。このオブジェクトでは、個々のキャンセル トークンへのキャンセル通知を管理し、送信します。

  • CancellationTokenSource.Token プロパティによって返されるトークンを、キャンセルをリッスンしているそれぞれのタスクまたはスレッドに渡します。

  • キャンセル トークンを CancellationToken.IsCancellationRequested 受け取る操作からメソッドを呼び出します。 取り消し要求に応答する各タスクまたはスレッドのメカニズムを提供します。 操作を取り消すかどうかを選択するかどうか、および操作の実行方法は、アプリケーション ロジックによって異なります。

  • キャンセルの通知を提供する CancellationTokenSource.Cancel メソッドを呼び出します。 これにより、 CancellationToken.IsCancellationRequested キャンセル トークン trueのすべてのコピーのプロパティが設定されます。

  • オブジェクトの Dispose 使用が完了したら、メソッドを CancellationTokenSource 呼び出します。

詳細については、「マネージド スレッドのキャンセル」を参照してください。

重要

この型は IDisposable インターフェイスを実装します。 型のインスタンスの使用が完了したら、直接または間接的に破棄する必要があります。 直接的に型を破棄するには、try/catch ブロック内で Dispose メソッドを呼び出します。 間接的に型を破棄するには、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)

指定されたトークンが取り消された状態であるときに、取り消された状態になる 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)
TryReset()

関連のない操作に使用する対象をリセット CancellationTokenSource しようとします。

適用対象

スレッド セーフ

すべてのパブリック メンバーと保護されたメンバー CancellationTokenSource はスレッド セーフであり、複数の Dispose()スレッドから同時に使用できます。ただし、例外を除き、オブジェクトに対 CancellationTokenSource する他のすべての操作が完了した場合にのみ使用する必要があります。

こちらもご覧ください