Free up resources with Cancellation while accessing APIs using HTTPClient in dotnet
HTTP Client
6 Articles
Table of Contents
What we gonna do?
Cancelling requests can be beneficial to performance, both at level of bandwidth consumption and scalability. Let's learn how and I'll guide you through this. We will start by learning why we should cancel requests when we no longer need them.
Why we gonna do?
Imagine we're using HttpClient to get a data. Chances are that the user of your application will navigate away or press a cancel button. In such a case, you want to be able to handle that instead of just letting the request continue. The reasoning behind this is that behind the scenes, HttpClient works with async tasks. There's another reason, though. It's not unheard of a timeout to happen. If that happens, we want to be notified of that so we can gracefully handle such a timeout. In such a case, it is due to the timeout that the task gets canceled.
It's important to know that cancelling a task that's no longer needed will free up the thread that is used to run the task. That means that thread is potentially returned to the thread pool where it can be used for other work. Cancellation in short helps to,
- Save threads which can be used to handle other tasks / requests.
- Save db calls which can save compute cost.
- Save data transferred over network.
How we gonna do?
Note: If you have not done so already, I recommend you read the article on Improving performance and memory use while accessing APIs using HTTPClient in dotnet.
Cancellation Token Source and Cancellation
To support cancelation of async tasks, a CancellationTokenSource and a CancellationToken are used. A CancellationTokenSource is an object, which manages and sends cancellation notifications to the individual cancellation tokens. It exposes such a CancellationToken via its token property. That CancellationToken is a lightweight value passed to one or more listeners, typically as a method parameter.
Listeners should then monitor the value of the IsCancellationRequested property of that token and react accordingly. From that, it follows that a CancellationToken is what we need to pass to each task returning method we want to listen to cancellation. So, the idea is that we provide these cancellation tokens to whichever part of our application we want to listen to cancellation and cancel itself. And we use the CancellationToken source to effectively request them to cancel themselves, which it does by sending notifications to those tokens.
Supporting Cancellation while reading data from API
All we need to do now is to initialize a CancellationTokenSource and set CancelAfter() a timeout. Then, we pass the token to the HTTPClient SendAsync method. We can then use the token to cancel the request if it takes too long. We can also use the token to cancel the request if the user navigates away.
Note: that for demo purpose we are cancelling after 10 seconds and we are awaiting for 5 seconds to simulate the API call failure. In real world scenario, you can set the timeout to 30 seconds or 1 minute or you can cancel when user presses cancel button.
Code Sample - Support Cancellation while Reading Data
Summary
In this article, we learned about how to free up resources with cancellation while accessing APIs using HTTP Client in .NET. We learned about what is CancellationTokenSource and why we should cancel requests when we no longer need them and advantages of cancellation. We also learned about how to support cancellation while reading data from API. I hope you enjoyed reading this article.