Masuit.Tools/Masuit.Tools.Abstractions/Net/PartialDownloader.cs

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading;

namespace Masuit.Tools.Net;

/// <summary>
/// 部分下载器
/// </summary>
public class PartialDownloader
{
    /// <summary>
    /// 这部分完成事件
    /// </summary>
    public event EventHandler DownloadPartCompleted;

    /// <summary>
    /// 部分下载进度改变事件
    /// </summary>
    public event EventHandler DownloadPartProgressChanged;

    /// <summary>
    /// 部分下载停止事件
    /// </summary>
    public event EventHandler DownloadPartStopped;

    private readonly AsyncOperation _aop = AsyncOperationManager.CreateOperation(null);
    private readonly int[] _lastSpeeds;
    private long _counter;
    private long _to;
    private long _totalBytesRead;
    private bool _wait;

    /// <summary>
    /// 下载已停止
    /// </summary>
    public bool Stopped { get; private set; }

    /// <summary>
    /// 下载已完成
    /// </summary>
    public bool Completed { get; private set; }

    /// <summary>
    /// 下载进度
    /// </summary>
    public int Progress { get; private set; }

    /// <summary>
    /// 下载目录
    /// </summary>
    public string Directory { get; }

    /// <summary>
    /// 文件名
    /// </summary>
    public string FileName { get; }

    /// <summary>
    /// 已读字节数
    /// </summary>
    public long TotalBytesRead => _totalBytesRead;

    /// <summary>
    /// 内容长度
    /// </summary>
    public long ContentLength { get; private set; }

    /// <summary>
    /// RangeAllowed
    /// </summary>
    public bool RangeAllowed { get; }

    /// <summary>
    /// url
    /// </summary>
    public string Url { get; }

    /// <summary>
    /// to
    /// </summary>
    public long To
    {
        get => _to;

        set
        {
            _to = value;
            ContentLength = _to - From + 1;
        }
    }

    /// <summary>
    /// from
    /// </summary>
    public long From { get; }

    /// <summary>
    /// 当前位置
    /// </summary>
    public long CurrentPosition => From + _totalBytesRead - 1;

    /// <summary>
    /// 剩余字节数
    /// </summary>
    public long RemainingBytes => ContentLength - _totalBytesRead;

    /// <summary>
    /// 完整路径
    /// </summary>
    public string FullPath => Path.Combine(Directory, FileName);

    /// <summary>
    /// 下载速度
    /// </summary>
    public int SpeedInBytes
    {
        get
        {
            if (Completed)
            {
                return 0;
            }

            int totalSpeeds = _lastSpeeds.Sum();
            return totalSpeeds / 10;
        }
    }

    /// <summary>
    /// 部分块下载
    /// </summary>
    /// <param name="url"></param>
    /// <param name="dir"></param>
    /// <param name="fileGuid"></param>
    /// <param name="from"></param>
    /// <param name="to"></param>
    /// <param name="rangeAllowed"></param>
    public PartialDownloader(string url, string dir, string fileGuid, long from, long to, bool rangeAllowed)
    {
        From = from;
        _to = to;
        Url = url;
        RangeAllowed = rangeAllowed;
        FileName = fileGuid;
        Directory = dir;
        _lastSpeeds = new int[10];
    }

    private void DownloadProcedure(Action<HttpWebRequest> config)
    {
        using (var file = new FileStream(FullPath, FileMode.Create, FileAccess.ReadWrite, FileShare.Delete))
        {
            var sw = new Stopwatch();
            if (WebRequest.Create(Url) is HttpWebRequest req)
            {
                req.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36";
                req.AllowAutoRedirect = true;
                req.MaximumAutomaticRedirections = 5;
                req.ServicePoint.ConnectionLimit += 1;
                req.ServicePoint.Expect100Continue = true;
                req.ProtocolVersion = HttpVersion.Version11;
                req.Proxy = WebRequest.GetSystemWebProxy();
                config(req);
                if (RangeAllowed)
                {
                    req.AddRange(From, _to);
                }

                if (req.GetResponse() is HttpWebResponse resp)
                {
                    ContentLength = resp.ContentLength;
                    if (ContentLength <= 0 || (RangeAllowed && ContentLength != _to - From + 1))
                    {
                        throw new Exception("Invalid response content");
                    }

                    using var tempStream = resp.GetResponseStream();
                    int bytesRead;
                    byte[] buffer = new byte[4096];
                    sw.Start();
                    while ((bytesRead = tempStream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        if (_totalBytesRead + bytesRead > ContentLength)
                        {
                            bytesRead = (int)(ContentLength - _totalBytesRead);
                        }

                        file.Write(buffer, 0, bytesRead);
                        _totalBytesRead += bytesRead;
                        _lastSpeeds[_counter] = (int)(_totalBytesRead / Math.Ceiling(sw.Elapsed.TotalSeconds));
                        _counter = (_counter >= 9) ? 0 : _counter + 1;
                        int tempProgress = (int)(_totalBytesRead * 100 / ContentLength);
                        if (Progress != tempProgress)
                        {
                            Progress = tempProgress;
                            _aop.Post(state =>
                            {
                                DownloadPartProgressChanged?.Invoke(this, EventArgs.Empty);
                            }, null);
                        }

                        if (Stopped || (RangeAllowed && _totalBytesRead == ContentLength))
                        {
                            break;
                        }
                    }
                }

                req.Abort();
            }

            sw.Stop();
            if (!Stopped && DownloadPartCompleted != null)
            {
                _aop.Post(state =>
                {
                    Completed = true;
                    DownloadPartCompleted(this, EventArgs.Empty);
                }, null);
            }

            if (Stopped && DownloadPartStopped != null)
            {
                _aop.Post(state => DownloadPartStopped(this, EventArgs.Empty), null);
            }
        }
    }

    /// <summary>
    /// 启动下载
    /// </summary>
    public void Start(Action<HttpWebRequest> config)
    {
        Stopped = false;
        var procThread = new Thread(_ => DownloadProcedure(config));
        procThread.Start();
    }

    /// <summary>
    /// 下载停止
    /// </summary>
    public void Stop()
    {
        Stopped = true;
    }

    /// <summary>
    /// 暂停等待下载
    /// </summary>
    public void Wait()
    {
        _wait = true;
    }

    /// <summary>
    /// 稍后唤醒
    /// </summary>
    public void ResumeAfterWait()
    {
        _wait = false;
    }
}