How to Cancel a Task.await Operation in C# After a Timeout?

Implementing Timeouts for Asynchronous Operations in C#

Managing asynchronous operations effectively often requires incorporating timeout mechanisms to prevent indefinite blocking. This article demonstrates how to cancel a Task.await operation in C# after a specified timeout period using CancellationTokenSource.

The CancellationTokenSource class provides a mechanism for controlling the cancellation of asynchronous tasks. By creating a CancellationTokenSource and passing its token to the task, you can trigger cancellation when needed.

Example Code:

The following C# code snippet illustrates the use of CancellationTokenSource to handle timeouts:

<code class="language-csharp">private static async Task<string> GetFinalUrl(PortalMerchant portalMerchant)
{
    // ... (Existing code for setting browser features and URL validation) ...

    Uri trackingUrl = new Uri(portalMerchant.Url);
    var cts = new CancellationTokenSource();
    var task = MessageLoopWorker.Run(DoWorkAsync, trackingUrl, cts.Token);

    // Use Task.WhenAny to monitor for task completion or timeout
    if (await Task.WhenAny(task, Task.Delay(5000, cts.Token)) == task)
    {
        // Task completed within the timeout
        if (!String.IsNullOrEmpty(task.Result?.ToString()))
        {
            return new Uri(task.Result.ToString()).ToString(); // Ensure string return
        }
        else
        {
            throw new Exception("Parsing Failed");
        }
    }
    else
    {
        // Timeout occurred
        cts.Cancel(); // Explicitly cancel the task
        throw new TimeoutException();
    }
}

static async Task<object> DoWorkAsync(object[] args)
{
    // ... (Existing code for web browser interaction) ...
}</code>

This improved code snippet explicitly handles potential null values and ensures a string is returned from GetFinalUrl. The use of Task.WhenAny elegantly waits for either the DoWorkAsync task to complete or the timeout to expire. If a timeout occurs, cts.Cancel() is called to cleanly cancel the asynchronous operation, and a TimeoutException is thrown. Error handling is improved to provide more specific exception messages. Remember to adapt MessageLoopWorker.Run to correctly handle the CancellationToken.

The above is the detailed content of How to Cancel a Task.await Operation in C# After a Timeout?. For more information, please follow other related articles on the PHP Chinese website!