Aracılığıyla paylaş


CancellationToken Yapı

Tanım

İşlemlerin iptal edilmesi gerektiği bildirimini yayılım.

public value class CancellationToken
public value class CancellationToken : IEquatable<System::Threading::CancellationToken>
public struct CancellationToken
public readonly struct CancellationToken
public readonly struct CancellationToken : IEquatable<System.Threading.CancellationToken>
[System.Runtime.InteropServices.ComVisible(false)]
public struct CancellationToken
type CancellationToken = struct
[<System.Runtime.InteropServices.ComVisible(false)>]
type CancellationToken = struct
Public Structure CancellationToken
Public Structure CancellationToken
Implements IEquatable(Of CancellationToken)
Devralma
CancellationToken
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek, on bir farklı aletten 10 tamsayı değeri okuyan bir veri toplama uygulamasına öykünmek için rastgele bir sayı oluşturucu kullanır. Sıfır değeri, ölçümün tek bir alet için başarısız olduğunu gösterir. Bu durumda işlem iptal edilmeli ve genel ortalama hesaplanmamalıdır.

İşlemin olası iptalini işlemek için örnek, bir nesneye geçirilen bir CancellationTokenSource iptal belirteci oluşturan bir TaskFactory nesnenin örneğini oluşturur. Buna karşılık nesne, TaskFactory iptal belirtecini belirli bir alet için okumaları toplamaktan sorumlu görevlerin her birine geçirir. Yöntemi TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) , ortalamanın ancak tüm okumalar başarıyla toplandıktan sonra hesaplandığından emin olmak için çağrılır. Bir görev iptal edildiği için tamamlanmamışsa, TaskFactory.ContinueWhenAll yöntem bir özel durum oluşturur.

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.

Açıklamalar

A CancellationToken , iş parçacıkları, iş parçacığı havuzu iş öğeleri veya Task nesneler arasında işbirliğine dayalı iptali etkinleştirir. Özelliğinden alınan iptal belirteçlerini yöneten bir nesne örneği oluşturarak bir CancellationTokenSource iptal belirteci CancellationTokenSource.Token oluşturursunuz. Ardından iptal belirtecini iptal bildirimini alması gereken herhangi bir sayıda iş parçacığına, göreve veya işlemlere geçirirsiniz. belirteç iptali başlatmak için kullanılamaz. Sahip olan nesne çağırdığında CancellationTokenSource.Cancel, IsCancellationRequested iptal belirtecinin her kopyasındaki özelliği olarak trueayarlanır. Bildirimi alan nesneler uygun şekilde yanıt verebilir.

Daha fazla bilgi ve kod örnekleri için bkz. Yönetilen İş Parçacıklarında İptal.

Oluşturucular

CancellationToken(Boolean)

CancellationTokenöğesini başlatır.

Özellikler

CanBeCanceled

Bu belirtecin iptal edilmiş durumda olup olmadığını alır.

IsCancellationRequested

Bu belirteç için iptal istenip istenmediğini alır.

None

Boş CancellationToken bir değer döndürür.

WaitHandle

Belirteç iptal edildiğinde sinyal veren bir WaitHandle alır.

Yöntemler

Equals(CancellationToken)

Geçerli CancellationToken örneğin belirtilen belirteçle eşit olup olmadığını belirler.

Equals(Object)

Geçerli CancellationToken örneğin belirtilen Objectöğesine eşit olup olmadığını belirler.

GetHashCode()

bir için CancellationTokenkarma işlevi işlevi görür.

Register(Action)

Bu CancellationToken işlem iptal edildiğinde çağrılacak bir temsilci kaydeder.

Register(Action, Boolean)

Bu CancellationToken iptal edildiğinde çağrılacak bir temsilciyi kaydeder.

Register(Action<Object,CancellationToken>, Object)

Bu CancellationToken iptal edildiğinde çağrılacak bir temsilciyi kaydeder.

Register(Action<Object>, Object)

Bu CancellationToken iptal edildiğinde çağrılacak bir temsilciyi kaydeder.

Register(Action<Object>, Object, Boolean)

Bu CancellationToken iptal edildiğinde çağrılacak bir temsilciyi kaydeder.

ThrowIfCancellationRequested()

Bu belirtecin iptali istendiyse bir OperationCanceledException oluşturur.

UnsafeRegister(Action<Object,CancellationToken>, Object)

Bu CancellationToken iptal edildiğinde çağrılacak bir temsilciyi kaydeder.

UnsafeRegister(Action<Object>, Object)

Bu CancellationToken iptal edildiğinde çağrılan bir temsilciyi kaydeder.

İşleçler

Equality(CancellationToken, CancellationToken)

İki CancellationToken örneğin eşit olup olmadığını belirler.

Inequality(CancellationToken, CancellationToken)

İki CancellationToken örneğin eşit olup olmadığını belirler.

Şunlara uygulanır

İş Parçacığı Güvenliği

tüm ortak ve korumalı üyeleri CancellationToken iş parçacığı güvenlidir ve birden çok iş parçacığından eşzamanlı olarak kullanılabilir.

Ayrıca bkz.