CancellationTokenSource Class

Public Constructors

• CancellationTokenSource()

  ( )
  Initializes a new instance of the CancellationTokenSource class.
• CancellationTokenSource(int millisecondsDelay)

  ( int millisecondsDelay )
  Initializes a new instance of the CancellationTokenSource class and sets the delay before cancellation.
• CancellationTokenSource(TimeSpan delay)

  ( TimeSpan delay )
  Initializes a new instance of the CancellationTokenSource class and sets the delay before cancellation.

Public Properties

• CancellationToken

  CancellationToken { get; }
  Gets the CancellationToken associated with this CancellationTokenSource instance.
• IsCancellationRequested

  bool { get; }
  Gets a value indicating whether cancellation has been requested for this token source.

Public Methods

• Cancel()

  ( )
  Notifies all waiting observers that a cancellation has been requested.
• Cancel(bool throwOnFirstException)

  ( bool throwOnFirstException )
  Notifies all waiting observers that a cancellation has been requested. If throwOnFirstException is true, and an exception occurs during cancellation, the first exception will be thrown.
• CancelAfter(int millisecondsDelay)

  ( int millisecondsDelay )
  Registers a delegate that will be invoked when cancellation is requested.
• CancelAfter(TimeSpan delay)

  ( TimeSpan delay )
  Registers a delegate that will be invoked when cancellation is requested.
• Dispose()

  ( )
  Releases all resources used by the current instance of the CancellationTokenSource class.

Public Static Methods

• CreateLinkedTokenSource(params CancellationToken[] tokens)

  ( params CancellationToken[] tokens )
  Creates a CancellationTokenSource that will be canceled when any of the supplied tokens is canceled.
• CreateLinkedTokenSource(params CancellationToken[] tokens)

  ( params CancellationToken[] tokens )
  Creates a CancellationTokenSource that will be canceled when any of the supplied tokens is canceled or after the specified delay.

Protected Methods

• Dispose(bool disposing)

  ( bool disposing )
  Releases the unmanaged resources used by the CancellationTokenSource and optionally releases the managed resources.

Example 1: Basic Cancellation

This example demonstrates how to use CancellationTokenSource to cancel a long-running operation.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
    public static async Task Main(string[] args)
    {
        // Create a CancellationTokenSource
        var cts = new CancellationTokenSource();
        CancellationToken token = cts.Token;

        Console.WriteLine("Starting a long-running operation...");

        // Start a task that can be cancelled
        var longRunningTask = Task.Run(() =>
        {
            try
            {
                for (int i = 0; i < 10; i++)
                {
                    // Check if cancellation has been requested
                    token.ThrowIfCancellationRequested();

                    Console.WriteLine($"Operation step {i}...");
                    Thread.Sleep(500); // Simulate work
                }
                Console.WriteLine("Long-running operation completed successfully.");
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("Operation was cancelled.");
            }
        }, token);

        // Wait for a moment, then request cancellation
        await Task.Delay(2000);
        Console.WriteLine("Requesting cancellation...");
        cts.Cancel();

        // Wait for the task to complete (either by finishing or being cancelled)
        await longRunningTask;

        // Clean up the CancellationTokenSource
        cts.Dispose();

        Console.WriteLine("Program finished.");
    }
}

Example 2: Cancellation with Delay

This example shows how to use CancelAfter to automatically cancel an operation after a specified time.

using System;
using System.Threading;
using System.Threading.Tasks;

public class ExampleWithDelay
{
    public static async Task Main(string[] args)
    {
        // Create a CancellationTokenSource that will cancel after 3 seconds
        var cts = new CancellationTokenSource();

        Console.WriteLine("Starting an operation that will be auto-cancelled in 3 seconds...");

        var operation = Task.Run(async () =>
        {
            try
            {
                cts.CancelAfter(3000); // Cancel after 3000 milliseconds
                for (int i = 0; i < 10; i++)
                {
                    if (cts.Token.IsCancellationRequested)
                    {
                        Console.WriteLine("Cancellation detected within loop.");
                        break;
                    }
                    Console.WriteLine($"Working... {i}");
                    await Task.Delay(1000, cts.Token); // Important: pass token to delay too
                }
                Console.WriteLine("Operation finished before auto-cancellation.");
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("Operation was cancelled by timer.");
            }
        });

        await operation;
        cts.Dispose();
        Console.WriteLine("Program finished.");
    }
}