この記事は機械翻訳されています。英語版の記事を表示するには、[英語] のチェック ボックスをオンにしてください。また、テキストにマウス ポインターを合わせると、ポップアップ ウィンドウに英語のテキストを表示することもできます。
翻訳
英語

CancellationTokenSource クラス

 

公開日: 2016年10月

取り消す必要があることを CancellationToken に通知します。

名前空間:   System.Threading
アセンブリ:  mscorlib (mscorlib.dll 内)

System.Object
  System.Threading.CancellationTokenSource

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class CancellationTokenSource : IDisposable

名前説明
System_CAPS_pubmethodCancellationTokenSource()

CancellationTokenSource クラスの新しいインスタンスを初期化します。

System_CAPS_pubmethodCancellationTokenSource(Int32)

指定した遅延 (ミリ秒単位) が経過した後に取り消される CancellationTokenSource クラスの新しいインスタンスを初期化します。

System_CAPS_pubmethodCancellationTokenSource(TimeSpan)

指定した期間の後に取り消される CancellationTokenSource クラスの新しいインスタンスを初期化します。

名前説明
System_CAPS_pubpropertyIsCancellationRequested

この CancellationTokenSource に対して取り消しが要求されているかどうかを取得します。

System_CAPS_pubpropertyToken

この CancellationToken に関連付けられている CancellationTokenSource を取得します。

名前説明
System_CAPS_pubmethodCancel()

取り消しの要求を伝えます。

System_CAPS_pubmethodCancel(Boolean)

キャンセルの要求を伝え、残りのコールバックとキャンセル可能な操作を続けるかどうかを指定します。

System_CAPS_pubmethodCancelAfter(Int32)

指定したミリ秒数が経過した後の、この CancellationTokenSource の取り消し操作をスケジュールします。

System_CAPS_pubmethodCancelAfter(TimeSpan)

指定した期間が経過した後の、この CancellationTokenSource の取り消し操作を設定します。

System_CAPS_pubmethodSystem_CAPS_staticCreateLinkedTokenSource(CancellationToken, CancellationToken)

すべてのソース トークンが取り消された状態であるときに、取り消された状態になる CancellationTokenSource を作成します。

System_CAPS_pubmethodSystem_CAPS_staticCreateLinkedTokenSource(CancellationToken[])

指定された配列のすべてのソース トークンが取り消された状態であるときに、取り消された状態になる CancellationTokenSource を作成します。

System_CAPS_pubmethodDispose()

CancellationTokenSource クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。

System_CAPS_protmethodDispose(Boolean)

CancellationTokenSource クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。

System_CAPS_pubmethodEquals(Object)

指定したオブジェクトが、現在のオブジェクトと等しいかどうかを判断します。(Object から継承されます。)

System_CAPS_protmethodFinalize()

オブジェクトがガベージ コレクションにより収集される前に、そのオブジェクトがリソースを解放し、その他のクリーンアップ操作を実行できるようにします。 (Object から継承されます。)

System_CAPS_pubmethodGetHashCode()

既定のハッシュ関数として機能します。(Object から継承されます。)

System_CAPS_pubmethodGetType()

現在のインスタンスの Type を取得します。(Object から継承されます。)

System_CAPS_protmethodMemberwiseClone()

現在の Object の簡易コピーを作成します。(Object から継承されます。)

System_CAPS_pubmethodToString()

現在のオブジェクトを表す文字列を返します。 (Object から継承されます。)

Starting with the net_v40_long, the .NET Framework uses a unified model for cooperative cancellation of asynchronous or long-running synchronous operations that involves two objects:

  • A T:System.Threading.CancellationTokenSource object, which provides a cancellation token through its P:System.Threading.CancellationTokenSource.Token property and sends a cancellation message by calling its M:System.Threading.CancellationTokenSource.Cancel or M:System.Threading.CancellationTokenSource.CancelAfter(System.Int32) method.

  • A T:System.Threading.CancellationToken object, which indicates whether cancellation is requested.

The general pattern for implementing the cooperative cancellation model is:

  • Instantiate a T:System.Threading.CancellationTokenSource object, which manages and sends cancellation notification to the individual cancellation tokens.

  • Pass the token returned by the P:System.Threading.CancellationTokenSource.Token property to each task or thread that listens for cancellation.

  • Call the P:System.Threading.CancellationToken.IsCancellationRequested method from operations that receive the cancellation token. Provide a mechanism for each task or thread to respond to a cancellation request. Whether you choose to cancel an operation, and exactly how you do it, depends on your application logic.

  • Call the M:System.Threading.CancellationTokenSource.Cancel(System.Boolean) method to provide notification of cancellation. This sets the P:System.Threading.CancellationToken.IsCancellationRequested property on every copy of the cancellation token to true.

  • Call the M:System.Threading.CancellationTokenSource.Dispose method when you are finished with the T:System.Threading.CancellationTokenSource object.

For more information, see Cancellation.

System_CAPS_important重要

This type implements the T:System.IDisposable interface. When you have finished using an instance of the type, you should dispose of it either directly or indirectly. To dispose of the type directly, call its M:System.IDisposable.Dispose method in a try/catch block. To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). For more information, see the “Using an Object that Implements IDisposable” section in the T:System.IDisposable interface topic.

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.

To handle the possible cancellation of the operation, the example instantiates a T:System.Threading.CancellationTokenSource object that generates a cancellation token which is passed to a T:System.Threading.Tasks.TaskFactory object. The T:System.Threading.Tasks.TaskFactory object in turn passes the cancellation token to each of the tasks responsible for collecting readings for a particular instrument. The M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken) method is called to ensure that the mean is computed only after all readings have been gathered successfully. If a task has not because it has been cancelled, the call to the M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken) 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.

ユニバーサル Windows プラットフォーム
8 以降で使用可能
.NET Framework
4.0 以降で使用可能
ポータブル クラス ライブラリ
サポート対象: 移植可能 .NET プラットフォーム
Silverlight
5.0 以降で使用可能
Windows Phone Silverlight
8.0 以降で使用可能
Windows Phone
8.1 以降で使用可能

All public and protected members of T:System.Threading.CancellationTokenSource are thread-safe and may be used concurrently from multiple threads, with the exception of M:System.Threading.CancellationTokenSource.Dispose, which must only be used when all other operations on the T:System.Threading.CancellationTokenSource object have completed.

トップに戻る
表示: