Runtime: WebClient.CancelAsync won't cancel an in-progress download.

[karelz]

Triage: We consider WebClient legacy API. We recommend moving to HttpClient instead for better perf, reliability and feature richness.

[waltdestler]

@karelz

Triage: We consider WebClient legacy API. We recommend moving to HttpClient instead for better perf, reliability and feature richness.

That's disappointing to hear, considering this is a regression from .NET Framework that breaks existing code. Also, despite the claim of "feature richness", HttpClient does lack some features compared WebClient; for example, it lacks a convenient way to track download progress.

[EatonZ]

@karelz Please reconsider - as @waltdestler stated, using WebClient is better in the case where download progress needs to be tracked. In all other cases, I agree that HttpClient is better... but not this one.😉

[waltdestler]

@EatonZ If it helps, I wrote an async wrapper method around HttpClient that can be used to download a file, can track progress via a callback, can be canceled via a CancellationToken, and can handle local files (which HttpClient can't):

```C#
///

/// Downloads a file from the specified Uri into the specified stream.
///

/// An optional CancellationToken that can be used to cancel the in-progress download.
/// If not null, will be called as the download progress. The first parameter will be the number of bytes downloaded so far, and the second the total size of the expected file after download.
/// A task that is completed once the download is complete.
public static async Task DownloadFileAsync(Uri uri, Stream toStream, CancellationToken cancellationToken = default, Action progressCallback = null)
{
if(uri == null)
throw new ArgumentNullException(nameof(uri));
if(toStream == null)
throw new ArgumentNullException(nameof(toStream));

        if(uri.IsFile)
        {
            await using Stream file = File.OpenRead(uri.LocalPath);

            if(progressCallback != null)
            {
                long length = file.Length;
                byte[] buffer = new byte[4096];
                int read;
                int totalRead = 0;
                while((read = await file.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false)) > 0)
                {
                    await toStream.WriteAsync(buffer, 0, read, cancellationToken).ConfigureAwait(false);
                    totalRead += read;
                    progressCallback(totalRead, length);
                }
                Debug.Assert(totalRead == length || length == -1);
            }
            else
            {
                await file.CopyToAsync(toStream, cancellationToken).ConfigureAwait(false);
            }
        }
        else
        {
            using HttpClient client = new HttpClient();
            using HttpResponseMessage response = await client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);

            if(progressCallback != null)
            {
                long length = response.Content.Headers.ContentLength ?? -1;
                await using Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                byte[] buffer = new byte[4096];
                int read;
                int totalRead = 0;
                while((read = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false)) > 0)
                {
                    await toStream.WriteAsync(buffer, 0, read, cancellationToken).ConfigureAwait(false);
                    totalRead += read;
                    progressCallback(totalRead, length);
                }
                Debug.Assert(totalRead == length || length == -1);
            }
            else
            {
                await response.Content.CopyToAsync(toStream).ConfigureAwait(false);
            }
        }
    }

```

(Note that this creates a new HttpClient object on every call, which isn't ideal if you make a lot of downloads. In that case, you might want to use a global HttpClient object that lives for the duration of your program.)

Hope that helps!

[EatonZ]

@waltdestler Thanks for sharing that. Stuff like this should be built in by default!

[616E64726173]

If WebClient is "legacy" and that is the reason you won't fix this buggy behavior, then remove the CancelASync method from it so that people don't waste hours trying to fix something that is dead on arrivial.

Leaving this unfixed for years because it's 'legacy' is not an acceptable excuse.