Cancellable Async Web Request

Question

I am trying to make a generic method that will cancel an Async web request and any additional operations associated with it. I found another question regarding this such as this.

And I have written a helper class that will do just this. I present it below:

     public static class Helpers
    {
        public static async Task<string> GetJson(string url,
            CancellationTokenSource cancellationTokenSource,
            bool useSynchronizationContext = true)
        {
            try
            {
                var request = (HttpWebRequest)WebRequest.Create(url);
                string jsonStringResult;
                using (WebResponse response = await request.GetResponseAsync()
                    .WithCancellation(cancellationTokenSource.Token,
                    request.Abort, useSynchronizationContext))
                {
                    Stream dataStream = response.GetResponseStream();
                    StreamReader reader = new StreamReader(dataStream);
                    jsonStringResult = await reader.ReadToEndAsync();
                    reader.Close();
                    dataStream.Close();
                }

                cancellationTokenSource.Token.ThrowIfCancellationRequested();

                return jsonStringResult;
            }
            catch (Exception ex) when (ex is OperationCanceledException
                || ex is TaskCanceledException)
            {

            }
            catch (Exception ex) when (ex is WebException
                && ((WebException)ex).Status == WebExceptionStatus.RequestCanceled)
            {

            }
            catch (Exception ex)
            {
                //Any other exception
            }
            finally
            {
                cancellationTokenSource.Dispose();
            }
            return default;
        }


        public static async Task<T> WithCancellation<T>(this Task<T> task,
            CancellationToken cancellationToken, Action action,
            bool useSynchronizationContext)
        {
            using (cancellationToken.Register(action, useSynchronizationContext))
            {
                return await task;
            }
        }
    }

Notice the line

cancellationTokenSource.Token.ThrowIfCancellationRequested();

right before returning the JSON string.

When the operation is canceled and the flow of execution is on line

StreamReader reader = new StreamReader(dataStream);

for example, all lines below (reader.Close() etc.) will be executed and the exception will be thrown when ThrowIfCancelationRequested() is executed - is that correct? Am I missing something?

If so, is there a way to cancel everything at once?

Thanks everyone for their response,

After the answer provided and all really useful comments I updated the implementation.I used HttpClient and the extension method in the link for having a task that cannot actually being canceled to behave like one that can - readAsStringAsync is actually executed since it cannot accept a cancellation token.

public static class Helpers
    {
        public static async Task<string> GetJson(string url,CancellationToken cancellationToken)
        {
            try
            {
                string jsonStringResult;

                using (var client = new HttpClient())
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    using (var response = await client.GetAsync(url, cancellationToken))
                    {
                        jsonStringResult = await response.Content.ReadAsStringAsync().WithCancellation(cancellationToken);
                    }
                }

                return jsonStringResult;
            }
            catch (Exception ex) when (ex is OperationCanceledException)
            {

            }
            catch (Exception ex) when (ex is WebException exception && exception.Status == WebExceptionStatus.RequestCanceled)
            {

            }
            catch (Exception ex)
            {
                //LogException(ex);
            }
            return default;
        }

        public static Task<T> WithCancellation<T>(this Task<T> task, CancellationToken cancellationToken)
        {
            return task.IsCompleted 
                ? task: task.ContinueWith(completedTask => completedTask.GetAwaiter().GetResult(),cancellationToken,TaskContinuationOptions.ExecuteSynchronously,TaskScheduler.Default);
        }
    }

Answer 1

all lines below (reader.Close() etc.) will be executed and the exception will be thrown when ThrowIfCancelationRequested() is executed - is that correct? Am I missing something?

If so, is there a way to cancel everything at once?

First of all, operation that you want to cancel has to explicitly support being canceled. So, you have to push your best to use a code for executing some operation in a way which somehow takes CancellationToken as an argument. If it is not possible, then you have no other chance.

That's why this concept is called Cooperative cancellation. Because almost always both sides should be aware of that cancellation happened. Client-side should be aware of that the code was actually canceled, it’s not enough for a client to know that cancellation was just requested. For the callee, it’s important to know about the fact that cancellation was requested in order to properly finish itself.

Regarding to checking whether operation is cancelled while executing Close method of stream and reader. You have to call cleanup methods always whether operation is cancelled or not if you want to avoid memory leaks. Of course I suggest you to use using statement which will automatically do that cleanup.

And by the way, for making some function cancelable you don't have to check whether cancellation is requested before executing each line. You just have to check whether cancellation is request before and after executing some long-running operation. And pass cancellation token if that long-running operations supports cancelling through cancellation token property.

Also, you have to take a look for side-effects. Don’t cancel if you’ve already incurred side-effects that your method isn’t prepared to revert on the way out that would leave you in an inconsistent state.

Some general code-block might be so:

if(ct.IsCancellationRequested)
{
    break; // or throw
}

await DoSomething(ct);

if (ct.IsCancellationRequested)
{
    // if there is no side-effect
    return; // or throw

    // or, we already did something in `DoSomething` method
    // do some rollback
}

As a solution, you can use some different objects like HttpClient or WebRequest for executing async, awaitable and cancelable web request. You can take a look to that link for implementation details.