다음을 통해 공유

CancellationTokenSource 클래스

  • 참조

정의

네임스페이스:
System.Threading
어셈블리:
System.Threading.Tasks.dll
어셈블리:
System.Runtime.dll
어셈블리:
mscorlib.dll
어셈블리:
netstandard.dll
Source:
CancellationTokenSource.cs
Source:
CancellationTokenSource.cs
Source:
CancellationTokenSource.cs

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개의 정수 값을 읽는 데이터 수집 애플리케이션을 에뮬레이트합니다. 값이 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는 두 개체가 포함된 비동기 또는 장기 실행 동기 작업의 협조적 취소를 위해 통합 모델을 사용합니다.

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

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

중요하다

이 형식은 IDisposable 인터페이스를 구현합니다. 형식의 인스턴스 사용을 마쳤으면 직접 또는 간접적으로 삭제해야 합니다. 형식을 직접 삭제하려면 try/finally 블록에서 해당 Dispose 메서드를 호출합니다. 간접적으로 삭제하려면 using(C#) 또는 Using(Visual Basic)와 같은 언어 구문을 사용합니다. 자세한 내용은 IDisposable 인터페이스 항목의 "IDisposable을 구현하는 개체 사용" 섹션을 참조하세요.

생성자

CancellationTokenSource()

CancellationTokenSource 클래스의 새 인스턴스를 초기화합니다.
CancellationTokenSource(Int32)

지정된 지연 시간(밀리초) 후에 취소될 CancellationTokenSource 클래스의 새 인스턴스를 초기화합니다.
CancellationTokenSource(TimeSpan)

지정된 시간 범위 후에 취소될 CancellationTokenSource 클래스의 새 인스턴스를 초기화합니다.
CancellationTokenSource(TimeSpan, TimeProvider)

지정된 TimeSpan후에 취소될 CancellationTokenSource 클래스의 새 인스턴스를 초기화합니다.

속성

IsCancellationRequested

이 CancellationTokenSource대해 취소가 요청되었는지 여부를 가져옵니다.
Token

이 CancellationTokenSource연결된 CancellationToken 가져옵니다.

메서드

Cancel()

취소 요청을 전달합니다.
Cancel(Boolean)

취소 요청을 전달하고 예외가 발생할 경우 나머지 콜백 및 취소 가능한 작업을 처리해야 하는지 여부를 지정합니다.
CancelAfter(Int32)

지정된 시간(밀리초) 후 이 CancellationTokenSource 취소 작업을 예약합니다.
CancelAfter(TimeSpan)

지정된 시간 범위 후에 이 CancellationTokenSource 취소 작업을 예약합니다.
CancelAsync()

취소 요청을 비동기적으로 전달합니다.
CreateLinkedTokenSource(CancellationToken)

제공된 토큰이 취소된 상태일 때 취소된 상태에 있는 CancellationTokenSource 만듭니다.
CreateLinkedTokenSource(CancellationToken, CancellationToken)

원본 토큰이 취소된 상태일 때 취소된 상태에 있는 CancellationTokenSource 만듭니다.
CreateLinkedTokenSource(CancellationToken[])

지정된 배열의 원본 토큰이 취소된 상태일 때 취소된 상태에 있는 CancellationTokenSource 만듭니다.
CreateLinkedTokenSource(ReadOnlySpan<CancellationToken>)

원본 토큰이 취소된 상태일 때 취소된 상태에 있는 CancellationTokenSource 만듭니다.
Dispose()

CancellationTokenSource 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다.
Dispose(Boolean)

CancellationTokenSource 클래스에서 사용하는 관리되지 않는 리소스를 해제하고 필요에 따라 관리되는 리소스를 해제합니다.
Equals(Object)

지정된 개체가 현재 개체와 같은지 여부를 확인합니다.

(다음에서 상속됨 Object)
GetHashCode()

기본 해시 함수로 사용됩니다.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type 가져옵니다.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object단순 복사본을 만듭니다.

(다음에서 상속됨 Object)
ToString()

현재 개체를 나타내는 문자열을 반환합니다.

(다음에서 상속됨 Object)
TryReset()

관련 없는 작업에 사용할 CancellationTokenSource 다시 설정하려고 시도합니다.

적용 대상

스레드 보안

CancellationTokenSource 모든 공용 및 보호된 멤버는 스레드로부터 안전하며 CancellationTokenSource 개체의 다른 모든 작업이 완료된 경우에만 사용해야 하는 Dispose()제외하고 여러 스레드에서 동시에 사용할 수 있습니다.

추가 정보