TaskCompletionSource and CancellationTokenSource in .NET

Introduction

The .NET framework provides a robust set of tools for handling asynchronous programming and managing the execution of concurrent operations. Two essential components in this realm are TaskCompletionSource and CancellationTokenSource. In this article, we will delve into these classes, exploring their functionalities, use cases, and how they contribute to building responsive and efficient applications.

TaskCompletionSource in .NET

TaskCompletionSource is a powerful class in the .NET Task Parallel Library (TPL) that allows developers to manually create and control the lifecycle of a Task. This class provides a bridge between synchronous and asynchronous code, enabling scenarios where the result of an asynchronous operation needs to be explicitly set.

Creating a Task with TaskCompletionSource

Let's look at a basic example to understand how TaskCompletionSource works. Suppose you have a method that performs a time-consuming operation and needs to return a Task<int> representing the result.

public Task<int> PerformAsyncOperation()
{
    TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();

    // Simulating an asynchronous operation
    Task.Run(() =>
    {
        // Perform some time-consuming operation
        int result = 42;

        // Set the result when the operation is complete
        tcs.SetResult(result);
    });

    return tcs.Task;
}

In this example, Task.Run is used to simulate an asynchronous operation and the TaskCompletionSource is employed to create a Task<int> whose result is explicitly set when the operation completes.

Handling Errors and Cancellation with TaskCompletionSource

TaskCompletionSource can also be used to handle errors or cancellations within an asynchronous operation. For example, you can call SetException to signal that an exception occurred during the operation.

public Task<int> PerformAsyncOperationWithException()
{
    TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();

    Task.Run(() =>
    {
        try
        {
            // Simulate an operation that might throw an exception
            int result = 42 / 0;
            tcs.SetResult(result);
        }
        catch (Exception ex)
        {
            // Set the exception in the TaskCompletionSource
            tcs.SetException(ex);
        }
    });

    return tcs.Task;
}

Use Cases for TaskCompletionSource

Adapting Legacy Code: When working with code that wasn't originally designed for asynchronous operations, TaskCompletionSource can be used to create asynchronous wrappers.
Custom Asynchronous Operations: For scenarios where the built-in async/await pattern is not applicable TaskCompletionSource, provides a way to create custom asynchronous operations.
Fine-Grained Control: Developers may need more control over the execution flow, such as handling errors in specific ways or managing complex asynchronous workflows.

CancellationTokenSource in .NET

CancellationTokenSource is part of the CancellationToken framework, providing a way to generate and control a CancellationToken. This class is particularly useful in scenarios where you want to cancel asynchronous operations, providing a mechanism to gracefully stop ongoing tasks.

Creating a CancellationToken with CancellationTokenSource

Let's consider a scenario where you want to perform an asynchronous operation that can be canceled. CancellationTokenSource is used to create a CancellationToken, which is then passed to the asynchronous method.

public async Task<int> PerformCancelableAsyncOperation(CancellationToken cancellationToken)
{
    await Task.Delay(5000, cancellationToken); // Simulated async operation

    return 42;
}

To initiate a cancellation, you create a CancellationTokenSource, cancel it when necessary, and pass the associated CancellationToken to the asynchronous method.

public async Task PerformCancellationExample()
{
    using (CancellationTokenSource cts = new CancellationTokenSource())
    {
        Task<int> operationTask = PerformCancelableAsyncOperation(cts.Token);

        // Perform other tasks or wait for user input

        // Cancel the operation if needed
        cts.Cancel();

        try
        {
            int result = await operationTask;
            Console.WriteLine($"Result: {result}");
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("Operation was canceled.");
        }
    }
}

Use Cases for CancellationTokenSource

User-Initiated Cancellation: In applications with user interfaces, CancellationTokenSource can be used to respond to user actions, such as cancel buttons.
Timeout Handling: When you want to set a timeout for an asynchronous operation, CancellationTokenSource can be used with Task.Delay.
Cancellation of Parallel Tasks: In scenarios where multiple parallel tasks are running, CancellationTokenSource can be shared among these tasks to cancel them collectively.

Conclusion

In the world of asynchronous programming in .NET, TaskCompletionSource, and CancellationTokenSource are invaluable tools for developers. They provide flexibility and control over asynchronous operations, enabling the creation of responsive and efficient applications. Whether you need to create custom asynchronous workflows, adapt legacy code, or gracefully handle cancellations, these classes play a crucial role in building robust and responsive software solutions. Understanding their usage and incorporating them into your toolkit will enhance your ability to create high-performance and user-friendly applications in the .NET ecosystem.