CancellationTokenSource 클래스

정의

네임스페이스:

System.Threading

어셈블리:

System.Threading.Tasks.dll

어셈블리:

System.Runtime.dll

어셈블리:

mscorlib.dll

어셈블리:

netstandard.dll

취소되도록 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

예제

다음 예제에서는 정수 값 10 11 개의 다양 한 계측에서 읽는 데이터 컬렉션 애플리케이션을 에뮬레이트 하려면 난수 생성기를 사용 합니다. 값이 0이면 하나의 계측에 대해 측정이 실패했음을 나타냅니다. 이 경우 작업을 취소해야 하며 전체 평균을 계산하지 않아야 합니다.

작업의 가능한 취소를 처리하기 위해 예제에서는 개체에 전달되는 취소 토큰을 생성하는 개체를 TaskFactory 인스턴스화 CancellationTokenSource 합니다. 개체는 TaskFactory 취소 토큰을 특정 계측에 대한 판독값 수집을 담당하는 각 작업에 전달합니다. 메서드 TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) 는 모든 판독값이 성공적으로 수집된 후에만 평균이 계산되도록 호출됩니다. 작업이 취소되어 완료되지 않은 경우 메서드에 대한 TaskFactory.ContinueWhenAll 호출은 예외를 throw합니다.

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 또는 CancelAfter 메서드를 호출 Cancel 하여 취소 메시지를 보내는 개체입니다.

• CancellationToken 취소가 요청되었는지 여부를 나타내는 개체입니다.

협조적 취소 모델을 구현하는 일반적인 패턴은 다음과 같습니다.

• 개별 취소 토큰을 관리하고 토큰에 취소 알림을 보내는 CancellationTokenSource 개체를 인스턴스화합니다.

• CancellationTokenSource.Token 속성에서 반환된 토큰을 취소를 수신 대기하는 각 작업이나 스레드에 전달합니다.

• 취소 토큰을 CancellationToken.IsCancellationRequested 받는 작업에서 메서드를 호출합니다. 각 태스크 또는 스레드가 취소 요청에 응답할 수 있는 메커니즘을 제공합니다. 작업을 하는 방법은 취소할 것인지 여부는 애플리케이션 논리에 따라 달라 집니다.

• CancellationTokenSource.Cancel 메서드를 호출하여 취소 알림을 제공합니다. 그러면 취소 토큰의 CancellationToken.IsCancellationRequested 모든 복사본에 대한 속성이 .로 설정됩니다 true.

• 개체를 Dispose 완료하면 메서드를 호출합니다 CancellationTokenSource .

자세한 내용은 관리되는 스레드의 취소를 참조하세요.

중요

이 형식이 구현 하는 IDisposable 인터페이스입니다. 형식의 인스턴스 사용을 완료한 경우 직접 또는 간접적으로 삭제해야 합니다. 직접 형식의 dispose 호출 해당 Dispose 의 메서드를 try/catch 블록입니다. 삭제 하지 직접, 언어 구문 같은 사용 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 다른 모든 작업이 완료된 경우에만 사용해야 합니다.

추가 정보

• 취소
• 작업 취소