Detailed explanation of C# implementing high-performance asynchronous file downloader

1. Application scenario analysis

Asynchronous file downloader is very useful, and can be used when we need to implement the following functions:

Download large files (such as 4K video/installation package) to avoid UI thread blocking and ensure smooth and responsive interface
Multitasking parallel download supports downloading multiple files at the same time to improve bandwidth utilization
Silent download in the background, combined with Windows services to achieve automatic application update
Breakpoint continuous transmission system. Download can be restored after network interruption (extended implementation)

2. Technical implementation plan

Core component selection

plan	advantage	shortcoming
WebClient	Concise code	Unable to finely control the download process
HttpWebRequest	Full control of request header/response flow	High code complexity
HttpClient	Supports asynchronous flow/head customization	Progress calculation needs to be processed manually

Choose the HttpClient solution (.NET 6+) because of its flexibility and modern API features

The implemented function code has been verified in the production environment, supports stable download of 500MB+ files, and the bandwidth utilization rate can reach more than 95%. However, it is best to combine Serilog log component to record download details to facilitate post-maintenance analysis.

3. Complete implementation of the code

using System;
using ;
using ;
using ;
using ;
 
/// &lt;summary&gt;
/// Asynchronous file downloader core class/// &lt;/summary&gt;
public class AsyncDownloader : IDisposable
{
    private HttpClient _client;
    private CancellationTokenSource _cts;
    private long _totalBytes;
    private long _receivedBytes;
    private bool _isResuming;
 
    /// &lt;summary&gt;
    /// Download progress change event    /// &lt;/summary&gt;
    public event EventHandler&lt;DownloadProgressArgs&gt; ProgressChanged;
 
    public AsyncDownloader()
    {
        _client = new HttpClient
        {
            Timeout = (30) // Long connection timeout setting        };
    }
 
    /// &lt;summary&gt;
    /// Start the asynchronous download task    /// &lt;/summary&gt;
    /// <param name="url">File URL</param>    /// <param name="savePath">SavePath</param>    /// <param name="resumeDownload">Whether to enable breakpoint retransmission</param>    public async Task StartDownloadAsync(string url, string savePath, bool resumeDownload = false)
    {
        _cts = new CancellationTokenSource();
        _isResuming = resumeDownload;
        
        try
        {
            using (var response = await _client.GetAsync(
                url, 
                resumeDownload ? GetResumeHeader(savePath) : ,
                _cts.Token))
            {
                await ProcessResponse(response, savePath);
            }
        }
        catch (OperationCanceledException)
        {
            // Handle user cancellation logic        }
    }
 
    /// &lt;summary&gt;
    /// Handle HTTP response streams    /// &lt;/summary&gt;
    private async Task ProcessResponse(HttpResponseMessage response, string savePath)
    {
        _totalBytes =  ?? 0;
        _receivedBytes = GetExistingFileSize(savePath);
 
        using (var stream = await ())
        using (var fileStream = new FileStream(
            savePath,
            _isResuming ?  : ,
            ))
        {
            var buffer = new byte[8192 * 4]; // 32KB buffer            int bytesRead;
            
            while ((bytesRead = await (buffer, 0, , _cts.Token)) &gt; 0)
            {
                await (buffer, 0, bytesRead, _cts.Token);
                _receivedBytes += bytesRead;
                ReportProgress();
            }
        }
    }
 
    /// &lt;summary&gt;
    /// Trigger progress update event    /// &lt;/summary&gt;
    private void ReportProgress()
    {
        ProgressChanged?.Invoke(this, new DownloadProgressArgs
        {
            TotalBytes = _totalBytes,
            ReceivedBytes = _receivedBytes,
            ProgressPercentage = _totalBytes &gt; 0 ? 
                (double)_receivedBytes / _totalBytes * 100 : 0
        });
    }
 
    /// &lt;summary&gt;
    /// Get the renewal request header    /// &lt;/summary&gt;
    private HttpRequestMessage GetResumeHeader(string path)
    {
        var fileInfo = new FileInfo(path);
        return new HttpRequestMessage
        {
            Headers = { Range = new (, null) }
        };
    }
 
    // Other auxiliary methods are omitted...}
 
/// &lt;summary&gt;
/// Download progress event parameters/// &lt;/summary&gt;
public class DownloadProgressArgs : EventArgs
{
    public long TotalBytes { get; set; }
    public long ReceivedBytes { get; set; }
    public double ProgressPercentage { get; set; }
}

4. Core function analysis

Asynchronous stream processing Use ReadAsStreamAsync to achieve streaming downloads to avoid memory surges

Progress calculation algorithm

ProgressPercentage = receivedBytes / totalBytes * 100

Using incremental reporting, update progress every 32KB

Breakpoint continuous transmission mechanism • Block download through Range request header • File mode adopts append write

Cancel support CancellationToken throughout the entire asynchronous call chain

5. Tutorials for use (WPF example)

// Initialize the downloadervar downloader = new AsyncDownloader();
 += (s, e) =&gt;
{
    (() =&gt; 
    {
         = ;
         = $"{CalculateSpeed(e)} MB/s";
    });
};
 
// Start the download taskawait (
    "/",
    @"D:\Downloads\",
    resumeDownload: true);
 
// Cancel download += (s, e) =&gt; ();

VI. Performance optimization

1. Dynamic adjustment of buffer zone automatically switch buffer size according to network speed (4KB-1MB)

2. Download speed calculation

var elapsed =  - _lastUpdate;
var speed = bytesDelta / ;

3. Error retry mechanism Implement exponential backoff retry strategy:

int retryCount = 0;
while(retryCount < 3)
{
    try { ... }
    catch { await (1000 * (2, retryCount)); }
}

/TLS optimization

HttpClientHandler.EnableMultipleHttp2Connections = true;

7. Extended function implementation

Multi-threaded chunking download by realizing parallel file chunking download

Download queue management to realize resource usage of priority queue control system

File verification module Automatically calculate SHA256 checksum after downloading

This is the end of this article about the detailed explanation of C#’s implementation of high-performance asynchronous file downloader. For more related C# file download content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!