Downloader源码剖析

1

new Download("url", "folder", "file", config, retryCount, onProgress, onError, saveMode, ...)

1
2
3
4
5
6

var download = DownloadBuilder.New()
    .WithUrl("https://example.com")
    .WithDirectory("Downloads")
    .WithFileName("file.zip")
    .WithConfiguration(config)
    .Build();

1
2
3

await download.StartAsync();
download.Pause();
download.Resume();

1

public DownloadPackage Package { get; set; }

1

public long DownloadedFileSize => _downloadService?.Package?.ReceivedBytesSize ?? 0;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/// <summary>
/// Sets the file chunks for the specified download package.
/// </summary>
/// <param name="package">The download package to set the chunks for.</param>
public void SetFileChunks(DownloadPackage package)
{
    Validate(package);
    if (package.Chunks is null)
    {
        package.Chunks = new Chunk[_chunkCount];
        for (int i = 0; i < _chunkCount; i++)
        {
            long startPosition = _startOffset + (i * _chunkSize);
            long endPosition = startPosition + _chunkSize - 1;
            package.Chunks[i] = GetChunk(i.ToString(), startPosition, endPosition);
        }
        package.Chunks.Last().End += package.TotalFileSize % _chunkCount; // add remaining bytes to last chunk
    }
    else
    {
        package.Validate();
    }
}

1
2
3
4
5
6

public class PauseTokenSource
{
    private volatile TaskCompletionSource<bool> _tcsPaused;
    public PauseToken Token => new(this);
    public bool IsPaused => _tcsPaused != null;
}

1
2
3
4

public void Pause()
{
    Interlocked.CompareExchange(ref _tcsPaused, new TaskCompletionSource<bool>(), null);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public void Resume()
{
    while (true)
    {
        TaskCompletionSource<bool> tcs = _tcsPaused;
        if (tcs == null)
            return;

        if (Interlocked.CompareExchange(ref _tcsPaused, null, tcs) == tcs)
        {
            tcs.SetResult(true);
            return;
        }
    }
}

1
2
3
4

internal Task WaitWhilePausedAsync()
{
    return _tcsPaused?.Task ?? Task.FromResult(true);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public record PauseToken
{
    private readonly PauseTokenSource _tokenSource;
    public bool IsPaused => _tokenSource?.IsPaused == true;

    public Task WaitWhilePausedAsync()
    {
        return IsPaused
            ? _tokenSource.WaitWhilePausedAsync()
            : Task.FromResult(true);
    }
}

1
2
3
4
5
6
7

private async Task WritePacketOnFile(Packet packet)
{
    // seek with SeekOrigin.Begin is so faster than SeekOrigin.Current
    Seek(packet.Position, SeekOrigin.Begin);
    await Stream.WriteAsync(packet.Data).ConfigureAwait(false);
    packet.Dispose();
}

1
2
3
4
5
6
7
8
9

ConcurrentStream.WriteAsync()
      ↓
InputBuffer.TryAdd(Packet)
      ↓
ConcurrentStream 的 Watcher 循环 WaitTryTakeAsync() 取包
      ↓
WritePacketOnFile(packet)
      ↓
写入文件 / 内存流

1
2
3
4

/// <summary>
/// Represents a client for making HTTP requests.
/// </summary>
public partial class SocketClient : IDisposable

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

private SocketsHttpHandler GetSocketsHttpHandler(RequestConfiguration config)
{
    SocketsHttpHandler handler = new() {
        AllowAutoRedirect = config.AllowAutoRedirect,
        MaxAutomaticRedirections = config.MaximumAutomaticRedirections,
        AutomaticDecompression = config.AutomaticDecompression,
        PreAuthenticate = config.PreAuthenticate,
        UseCookies = config.CookieContainer != null,
        UseProxy = config.Proxy != null,
        MaxConnectionsPerServer = 1000,
        PooledConnectionIdleTimeout = config.KeepAliveTimeout,
        PooledConnectionLifetime = Timeout.InfiniteTimeSpan,
        EnableMultipleHttp2Connections = true,
        ConnectTimeout = TimeSpan.FromMilliseconds(config.Timeout)
    };

    // Set up the SslClientAuthenticationOptions for custom certificate validation
    if (config.ClientCertificates?.Count > 0)
    {
        handler.SslOptions.ClientCertificates = config.ClientCertificates;
    }

    handler.SslOptions.EnabledSslProtocols = SslProtocols.Tls13 | SslProtocols.Tls12;
    handler.SslOptions.RemoteCertificateValidationCallback = ExceptionHelper.CertificateValidationCallBack;

    // Configure keep-alive
    if (config.KeepAlive)
    {
        handler.KeepAlivePingTimeout = config.KeepAliveTimeout;
        handler.KeepAlivePingPolicy = HttpKeepAlivePingPolicy.WithActiveRequests;
    }

    // Configure credentials
    if (config.Credentials != null)
    {
        handler.Credentials = config.Credentials;
        handler.PreAuthenticate = config.PreAuthenticate;
    }

    // Configure cookies
    if (handler.UseCookies && config.CookieContainer != null)
    {
        handler.CookieContainer = config.CookieContainer;
    }

    // Configure proxy
    if (handler.UseProxy && config.Proxy != null)
    {
        handler.Proxy = config.Proxy;
    }
    
    // Add expect header
    if (!string.IsNullOrWhiteSpace(config.Expect))
    {
        handler.Expect100ContinueTimeout = TimeSpan.FromSeconds(1);
    }
    
    return handler;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class MyClass
{
    // this is a field.  It is private to your class and stores the actual data.
    private string _myField;

    // this is a property. When accessed it uses the underlying field,
    // but only exposes the contract, which will not be affected by the underlying field
    public string MyProperty
    {
        get
        {
            return _myField;
        }
        set
        {
            _myField = value;
        }
    }

    // This is an AutoProperty (C# 3.0 and higher) - which is a shorthand syntax
    // used to generate a private field for you
    public int AnotherProperty { get; set; }
}

1
2
3
4

[GeneratedRegex(@"bytes\s*((?<from>\d*)\s*-\s*(?<to>\d*)|\*)\s*\/\s*(?<size>\d+|\*)", RegexOptions.Compiled)]
private static partial Regex RangePatternRegex();

private readonly Regex _contentRangePattern = RangePatternRegex();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

using System;
using System.Text.RegularExpressions;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class RegexBenchmarks
{
    private const string Pattern = @"bytes\s*((?<from>\d*)\s*-\s*(?<to>\d*)|\*)\s*\/\s*(?<size>\d+|\*)";
    private const string TestString = "bytes 0-499/1234";

    // 传统写法：运行时解析 + 编译
    private static readonly Regex OldRegex =
        new Regex(Pattern, RegexOptions.Compiled);

    // 新写法：编译时生成代码
    [GeneratedRegex(Pattern, RegexOptions.Compiled)]
    private static partial Regex NewRegex();

    [Benchmark(Baseline = true)]
    public Match OldRegexMatch()
    {
        return OldRegex.Match(TestString);
    }

    [Benchmark]
    public Match NewRegexMatch()
    {
        return NewRegex().Match(TestString);
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        BenchmarkRunner.Run<RegexBenchmarks>();
    }
}