[C#] 下载器与上传器使用示例

由于下载器与上传器实现原理相似，所以仅以下载器举例。

优势：

1. 创建多个下载器，例如负责数据管理模块的、负责专家服务的等；
2. 同时多个下载任务，例如可设置数据管理同时下载多个，而非逐个排队下载；
3. 多个下载任务可组合成一个下载任务组，一个下载任务可加入多个组，加入多个组不会重复下载；（加入多个组理论可行，但有些代码要完善。）
4. 下载任务及下载任务组都有进度值、下载速度，有下载进度改变通知、下载结束通知；
5. 下载过程中可处理预下载事件，可中途插入或移除下载任务；
6. 支持自定义的下载方式，只需实现抽象类，目前已提供常规的HTTP、FTP、SFTP、HTTP断点下载方式。

注：组仅是下载任务的整体统计，与下载器关系不大；

 

下面逐一举例。

示例一：创建负责不同模块的下载器。

var downloadEngine1 = DownloadEngine.Create("数据管理", 1, out var createNew);  // createNew = False
var downloadEngine2 = DownloadEngine.Create("专家服务", 1, out createNew);      // createNew = False
var downloadEngine3 = DownloadEngine.Create("数据管理", 2, out createNew);      // createNew = True，downloadEngine3 = downloadEngine1，同时下载数 = 1

 

示例二：多个下载任务同时下载。

// 创建3个任务同时下载的下载器
var downloadEngine = DownloadEngine.Create("数据管理", 3, out _);

 

示例三：多个下载任务组合成一个下载任务组。

var downloadEngine = DownloadEngine.Create("下载器名称", 1, out _);
var guid = Guid.NewGuid().ToString();
// 获取指定下载任务组，如果不存在则创建下载任务组
var downloadTaskGroup = downloadEngine.GetOrAdd(q => q.Code == guid, () =>
{
    // 创建三个不支持计算下载速度的下载任务
    var downloadTasks = new List<DownloadTask>
    {
        new DownloadTask{ Url="http://xxx.xxx/files/1.zip" },
        new DownloadTask{ Url="http://xxx.xxx/files/2.zip" },
        new DownloadTask{ Url="http://xxx.xxx/files/3.zip" }
    };
    // 创建一个支持计算下载速度的下载任务组
    return new DownloadTaskGroup(downloadTasks, true) { Code = guid };
});

 

示例四：更新下载任务的进度值、下载速度，处理下载进度改变通知、下载结束通知。

var downloadEngine = DownloadEngine.Create("下载器名称", 1, out _);
var guid = Guid.NewGuid().ToString();
var downloadTask = downloadEngine.GetOrAdd(q => q.Code == guid, () => new DownloadTask(true)    // true:计算下载速度
{
    Code = guid,
    Url = "http://xxx.xxx/files/1.zip"
});
downloadTask.DownloadProgressChanged += OnDownloadProgressChanged;      // 处理下载进度改变通知
downloadTask.DownloadFileCompleted += OnDownloadFileCompleted;          // 处理下载结束通知，可能是取消下载、下载失败、下载成功三种结果

 

示例五：处理下载任务的预下载通知，及中途插入和移除下载任务。

var downloadEngine = DownloadEngine.Create("下载器名称", 1, out _);
var guid = Guid.NewGuid().ToString();
var downloadTaskGroup = downloadEngine.GetOrAdd(q => q.Code == guid, () =>
{
    var downloadTask1 = new DownloadTask { Name = "下载1" };
    var downloadTask2 = new DownloadTask { Name = "下载2" };

    downloadTask1.PreviewDownload += delegate
    {
        // 如果此处返回失败或异常，则下载失败，及取消所在下载任务组
        // 在预下载时补充下载信息，比如在预上传时，才生成上传文件
        downloadTask1.Url = "http://xxx.xxx/files/1.zip";   

        // 插入下载任务
        var downloadTask3 = new DownloadTask { Name = "下载3" };

        downloadTask1.Group.Children.Add(downloadTask3);    // 加入所在任务组
        downloadEngine.Unshift(downloadTask3);              // 插入到最前面

        return ResultValue.Succeed; // 返回成功
    };

    downloadTask1.DownloadFileCompleted += delegate
    {
        if (downloadTask1.DownloadStatus == DownloadStatus.Completed)
        {
            // 例如下载检测包后，发现不需要下载安装包
            downloadEngine.RemoveWaitingTask(downloadTask2);    // 只能移除还未开始下载的任务
            downloadTask1.Group.Children.Remove(downloadTask2); // 同时在任务组中移除
        }
    };

    return new DownloadTaskGroup(new DownloadTask[] { downloadTask1, downloadTask2 }, true) { Code = guid };
});

 

示例六：支持HTTP、FTP、SFTP、自定义下载方式。

var downloadEngine = DownloadEngine.Create("下载器名称", 1, out _);
var guid = Guid.NewGuid().ToString();
var downloadTaskGroup = downloadEngine.GetOrAdd(q => q.Code == guid, () =>
{
    var downloadTask1 = new DownloadTask
    {
        Name = "HTTP下载",
        Url = "http://xxx.xxx/files/1.zip",             // 下载链接
        Headers = new Dictionary<string, string>(),     // 设置请求头
    };
    downloadTask1.CreateDownloadClient = () => new HttpDownloadClient(downloadTask1);   // HTTP是默认下载方式，可以不设置

    var downloadTask2 = new DownloadTask
    {
        Name = "FTP下载",
        Url = "ftp://192.168.0.1:22/files/1.zip",   // 下载链接
        Host = "192.168.0.1:22",                    // FTP主机地址
        Port = 22,                                  // 端口号
        UserName = "admin",                         // 用户名
        Password = "123456"                         // 密码
    };
    downloadTask2.CreateDownloadClient = () => new FtpDownloadClient(downloadTask2);

    var downloadTask3 = new DownloadTask
    {
        Name = "SFTP下载",
        Url = "./files/1.zip",          // 下载链接
        Host = "192.168.0.1:22",        // SFTP主机地址
        Port = 22,                      // 端口号
        UserName = "admin",             // 用户名
        Password = "123456"             // 密码
    };
    downloadTask3.CreateDownloadClient = () => new SftpDownloadClient(downloadTask3);

    var downloadTask4 = new DownloadTask
    {
        Name = "自定义下载",
        Url = "http://xxx.xxx/files/1.zip",             // 下载链接
        Headers = new Dictionary<string, string>(),     // 设置请求头
    };
    downloadTask4.CreateDownloadClient = () => new CustomDownloadClient(downloadTask4);     // 使用自定义方式下载，例如HTTP断点续传

    return new DownloadTaskGroup(new DownloadTask[] { downloadTask1, downloadTask2, downloadTask3 }, true) { Code = guid };
});

/// <summary>
/// 未实现的自定义下载方式
/// </summary>
public class CustomDownloadClient : DownloadClientBase
{
    public CustomDownloadClient(DownloadTask downloadTask) : base(downloadTask)
    {
        throw new NotImplementedException();
    }

    public override void BeginCancel()
    {
        throw new NotImplementedException();
    }

    public override void BeginDownload()
    {
        throw new NotImplementedException();
    }

    public override void Dispose()
    {
        throw new NotImplementedException();
    }

    public override ResultValue<long> GetFileSize()
    {
        throw new NotImplementedException();
    }
}

 

示例七：支持HTTP断点下载。

var downloadEngine = DownloadEngine.Create("下载器名称", 1, out _);
var guid = Guid.NewGuid().ToString();
var downloadTask = downloadEngine.GetOrAdd(q => q.Code == guid, () => {
    var download = new DownloadTask(true)    // true:计算下载速度
    {
        Code = guid,
        Url = "http://xxx.xxx/files/1.zip"
    };
    download.CreateDownloadClient = () => new HttpRangeDownloadClient(download); // HTTP断点下载
});

 

示例八：监控不同下载任务的更新进度，即使在不同的下载任务组。

var watcher = new DownloadProgressWatcher(); // 下载进度监听器

watcher.DownloadProgressChanged += OnDownloadProgressChanged;
watcher.DownloadFileCompleted += OnDownloadFileCompleted;

watcher.AppendDownloadTaskGroup(downloadTaskGroup); // 添加下载任务组
watcher.AppendDownloadTask(downloadTask); // 添加下载任务

 

下载器关键源码：

using Gnt.DTOs;
using Gnt.Events;
using Gnt.Events.PubSubEvents;
using Gnt.Extensions;
using Gnt.Ioc;
using Gnt.Mvvm;
using Renci.SshNet;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Gnt.Utils
{
    /// <summary>
    /// 下载器
    /// </summary>
    public sealed class DownloadEngine : IDisposable
    {
        #region Static

        /// <summary>
        /// 已创建下载器
        /// </summary>
        private static Dictionary<string, DownloadEngine> _downloadEngines = new Dictionary<string, DownloadEngine>();

        /// <summary>
        /// 创建下载器
        /// </summary>
        /// <param name="name">下载器名称</param>
        /// <param name="maximumCount">最大同时下载数</param>
        /// <param name="createdNew">是否创建了新的</param>
        /// <returns></returns>
        public static DownloadEngine Create(string name, int maximumCount, out bool createdNew)
        {
            lock (_downloadEngines)
            {
                createdNew = false;

                if (_downloadEngines.TryGetValue(name, out DownloadEngine downloadEngine))
                    return downloadEngine;

                downloadEngine = new DownloadEngine(name, maximumCount);
                _downloadEngines.Add(name, downloadEngine);

                createdNew = true;
                return downloadEngine;
            }
        }

        /// <summary>
        /// 获取下载器
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static DownloadEngine Get(string name)
        {
            lock (_downloadEngines)
            {
                if (_downloadEngines.TryGetValue(name, out DownloadEngine downloadEngine))
                    return downloadEngine;
                return null;
            }
        }

        #endregion

        /// <summary>
        /// 下载器
        /// </summary>
        /// <param name="name">下载器名称</param>
        /// <param name="maximumCount">最大同时下载数</param>
        private DownloadEngine(string name, int maximumCount)
        {
            Name = name;
            _maximumCount = maximumCount;
            _semaphore = new Semaphore(maximumCount, maximumCount);
        }

        #region Method

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            lock (locker)
            {
                foreach (var item in _waiting.ToArray())
                {
                    Remove(item);
                }
                foreach (var item in _downloading.Keys.ToArray())
                {
                    Remove(item);
                }
            }

            lock (_downloadEngines)
            {
                if (_semaphore != null)
                {
                    _semaphore.Dispose();
                    _semaphore = null;
                }

                _downloadEngines.Remove(Name);
            }
        }

        /// <summary>
        /// 加入下载任务
        /// </summary>
        /// <param name="downloadTask"></param>
        public void Add(DownloadTask downloadTask)
        {
            lock (locker)
            {
                if (_downloading.ContainsKey(downloadTask) || _waiting.Contains(downloadTask))
                    return;

                _waiting.Add(downloadTask);
                downloadTask.DownloadEngine = this;

                if (_thread == null)
                {
                    // 启动轮询线程
                    _thread = new Thread(new ThreadStart(Run)) { IsBackground = true };
                    _thread.Start();
                }
            }
        }

        /// <summary>
        /// 加入下载任务组
        /// </summary>
        /// <param name="multipleDownloadTask"></param>
        public void Add(DownloadTaskGroup downloadTaskGroup)
        {
            lock (locker)
            {
                foreach (var downloadTask in downloadTaskGroup.Children)
                {
                    Add(downloadTask);
                }
                downloadTaskGroup.DownloadEngine = this;
            }
        }

        /// <summary>
        /// 移除下载任务
        /// </summary>
        /// <param name="downloadTask"></param>
        public void Remove(DownloadTask downloadTask)
        {
            DownloadClientBase downloadClient = null;

            lock (locker)
            {
                if (_downloading.TryGetValue(downloadTask, out downloadClient))
                    _downloading.Remove(downloadTask);
                else if (_waiting.Remove(downloadTask))
                {
                    var groupStatus = downloadTask.Group?.DownloadStatus;

                    downloadTask.DownloadStatus = DownloadStatus.Cancelled;
                    downloadTask.DownloadFileCompleted?.Invoke(downloadTask);

                    if (downloadTask.Group != null)
                        downloadTask.Group.DownloadFileCompleted?.Invoke(downloadTask.Group);
                }
            }

            // 取消下载
            downloadClient?.BeginCancel();
        }

        /// <summary>
        /// 移除指定下载任务
        /// </summary>
        /// <param name="predicate"></param>
        public void Remove(Func<DownloadTask, bool> predicate)
        {
            lock (locker)
            {
                foreach (var item in _waiting.Where(predicate).ToArray())
                {
                    Remove(item);
                }

                foreach (var item in _downloading.Keys.Where(predicate).ToArray())
                {
                    Remove(item);
                }
            }
        }

        /// <summary>
        /// 移除指定下载任务组
        /// </summary>
        /// <param name="predicate"></param>
        public void Remove(Func<DownloadTaskGroup, bool> predicate)
        {
            lock (locker)
            {
                foreach (var item in _waiting.Where(q => q.Group != null && predicate.Invoke(q.Group)).ToArray())
                {
                    Remove(item);
                }

                foreach (var item in _downloading.Keys.Where(q => q.Group != null && predicate.Invoke(q.Group)).ToArray())
                {
                    Remove(item);
                }
            }
        }

        /// <summary>
        /// 移除下载任务组
        /// </summary>
        /// <param name="downloadTaskGroup"></param>
        public void Remove(DownloadTaskGroup downloadTaskGroup)
        {
            lock (locker)
            {
                foreach (var downloadTask in downloadTaskGroup.Children)
                {
                    Remove(downloadTask);
                }
            }
        }

        /// <summary>
        /// 移除等待中的下载任务，并且不触发事件
        /// </summary>
        /// <param name="downloadTask"></param>
        public bool RemoveWaitingTask(DownloadTask downloadTask)
        {
            lock (locker)
            {
                if (_waiting.Remove(downloadTask))
                {
                    downloadTask.DownloadStatus = DownloadStatus.Cancelled;

                    if (downloadTask.Group != null)
                    {
                        var group = downloadTask.Group;

                        downloadTask.Group = null;
                        group.Children.Remove(downloadTask);
                    }

                    downloadTask.Removed?.Invoke(downloadTask);

                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// 插入下载任务
        /// </summary>
        /// <param name="downloadTask"></param>
        public void Unshift(DownloadTask downloadTask)
        {
            lock (locker)
            {
                _waiting.Insert(0, downloadTask);
                downloadTask.DownloadEngine = this;

                if (downloadTask.Group != null)
                {
                    downloadTask.Group.Children.Add(downloadTask);
                    downloadTask.Group.Appended?.Invoke(downloadTask);
                }
            }
        }

        /// <summary>
        /// 插入下载任务
        /// </summary>
        public void UnshiftBefore(DownloadTask newDownloadTask, DownloadTask beforeDownloadTask)
        {
            lock (locker)
            {
                var index = _waiting.IndexOf(beforeDownloadTask);
                _waiting.Insert(index, newDownloadTask);
                newDownloadTask.DownloadEngine = this;

                if (newDownloadTask.Group != null)
                {
                    index = newDownloadTask.Group.Children.IndexOf(beforeDownloadTask);
                    if (index == -1)
                    {
                        newDownloadTask.Group.Children.Add(newDownloadTask);
                    }
                    else
                    {
                        newDownloadTask.Group.Children.Insert(index, newDownloadTask);
                    }
                    newDownloadTask.Group.Appended?.Invoke(newDownloadTask);
                }
            }
        }

        /// <summary>
        /// 获取下载任务
        /// </summary>
        /// <param name="status">下载状态   0:全部|1:等待下载|2:下载中</param>
        /// <returns></returns>
        public DownloadTask[] GetDownloadTasks(int status = 0)
        {
            lock (locker)
            {
                switch (status)
                {
                    case 1:
                        return _waiting.ToArray();
                    case 2:
                        return _downloading.Keys.ToArray();
                    default:
                        var list = new List<DownloadTask>(_waiting.Count + _downloading.Count);
                        list.AddRange(_waiting);
                        list.AddRange(_downloading.Keys);
                        return list.ToArray();
                }
            }
        }

        /// <summary>
        /// 获取下载任务组
        /// </summary>
        /// <param name="status">下载状态   0:全部|1:等待下载|2:下载中</param>
        /// <returns></returns>
        public DownloadTaskGroup[] GetDownloadTaskGroups(int status = 0)
        {
            lock (locker)
            {
                var list = new List<DownloadTaskGroup>();
                list.AddRange(_waiting.Where(q => q.Group != null).Select(q => q.Group));
                list.AddRange(_downloading.Keys.Where(q => q.Group != null).Select(q => q.Group));
                var query = list.Distinct();

                switch (status)
                {
                    case 1:
                        return query.Where(q => q.DownloadStatus == DownloadStatus.Waiting).ToArray();
                    case 2:
                        return query.Where(q => q.DownloadStatus == DownloadStatus.Downloading).ToArray();
                    default:
                        return query.ToArray();
                }
            }
        }

        public bool AnyTask(Func<DownloadTask, bool> predicate = null)
        {
            return (predicate == null ? _waiting.Any() : _waiting.Any(predicate)) || (predicate == null ? _downloading.Any() : _downloading.Keys.Any(predicate));
        }

        public Task<bool> AnyTaskGroupAsync(Func<DownloadTaskGroup, bool> predicate)
        {
            return Task.Run(() => AnyTaskGroup(predicate));
        }

        public bool AnyTaskGroup(Func<DownloadTaskGroup, bool> predicate)
        {
            return _waiting.Where(q => q.Group != null).Select(q => q.Group).Any(predicate) || _downloading.Keys.Where(q => q.Group != null).Select(q => q.Group).Any(predicate);
        }

        public DownloadTask GetDownloadTask(Func<DownloadTask, bool> predicate)
        {
            lock (locker)
            {
                return _waiting.FirstOrDefault(predicate) ?? _downloading.Keys.FirstOrDefault(predicate);
            }
        }

        public DownloadTaskGroup GetDownloadTaskGroup(Func<DownloadTaskGroup, bool> predicate)
        {
            lock (locker)
            {
                return _waiting.Where(q => q.Group != null).Select(q => q.Group).FirstOrDefault(predicate) ?? _downloading.Keys.Where(q => q.Group != null).Select(q => q.Group).FirstOrDefault(predicate);
            }
        }

        /// <summary>
        /// 查询第一个符合描述的下载任务
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public DownloadTask GetOrAdd(Func<DownloadTask, bool> predicate, Func<DownloadTask> create)
        {
            lock (locker)
            {
                var task = _waiting.FirstOrDefault(predicate);

                if (task != null)
                    return task;

                task = _downloading.Keys.FirstOrDefault(predicate);

                if (task != null)
                    return task;

                task = create.Invoke();

                if (task != null)
                    Add(task);

                return task;
            }
        }

        /// <summary>
        /// 查询第一个符合描述的下载任务组
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public DownloadTaskGroup GetOrAdd(Func<DownloadTaskGroup, bool> predicate, Func<DownloadTaskGroup> create)
        {
            lock (locker)
            {
                var group = _waiting.Where(q => q.Group != null).Select(q => q.Group).FirstOrDefault(predicate);

                if (group != null)
                    return group;

                group = _downloading.Keys.Where(q => q.Group != null).Select(q => q.Group).FirstOrDefault(predicate);

                if (group != null)
                    return group;

                group = create.Invoke();

                if (group != null)
                    Add(group);

                return group;
            }
        }

        /// <summary>
        /// 开始轮询等待下载队列
        /// </summary>
        private void Run()
        {
            try
            {
                ContainerLocator.Current.Resolve<IEventAggregator>().GetEvent<IsIdleEvent>().Publish((this, false));

                while (true)
                {
                    var ret = _semaphore.WaitOne(10000);

                    lock (locker)
                    {
                        if (!ret)
                        {
                            if (_downloading.Count < _maximumCount)
                            {
                                // 到这里一定是代码出错了
                                Log.Debug($"等待信号失败，强制释放{_maximumCount - _downloading.Count}信号量");

                                try
                                {
                                    TryRelease(_maximumCount - _downloading.Count);
                                }
                                catch { }
                            }
                            else if (_waiting.Count == 0 && _downloading.Count == 0)
                            {
                                _thread = null;
                                break;
                            }

                            continue;
                        }

                        if (_waiting.Count == 0 && _downloading.Count == 0)
                        {
                            _thread = null;
                            TryRelease();   // 耗费了一个信号，要释放一个
                            break;
                        }

                        if (_waiting.Count > 0)
                        {
                            var downloadTask = _waiting.First();
                            _waiting.Remove(downloadTask);
                            _downloading.Add(downloadTask, null);

                            ThreadPool.QueueUserWorkItem(Start, downloadTask);
                        }
                    }
                }
            }
            finally
            {
                ContainerLocator.Current.Resolve<IEventAggregator>().GetEvent<IsIdleEvent>().Publish((this, true));
            }
        }

        /// <summary>
        /// 开始新的下载任务
        /// </summary>
        /// <param name="state"></param>
        private void Start(object state)
        {
            var downloadTask = (DownloadTask)state;
            DownloadClientBase downloadClient = null;

            try
            {
                if (downloadTask.DownloadStatus == DownloadStatus.Completed)
                {
                    // 跳过，不触发事件
                    lock (locker)
                    {
                        _downloading.Remove(downloadTask);

                        if (_downloading.Count < _maximumCount)
                            TryRelease(_maximumCount - _downloading.Count);
                    }
                    return;
                }

                var groupStatus = downloadTask.Group == null ? DownloadStatus.Waiting : downloadTask.Group.DownloadStatus;
                downloadTask.DownloadStatus = DownloadStatus.Downloading;
                downloadTask.BeginTime = DateTime.Now;

                Log.Info($"开始下载，URL：{downloadTask.Url}");

                if (downloadTask.PreviewDownload != null)
                {
                    var ret = downloadTask.PreviewDownload.Invoke(downloadTask);

                    if (!ret.IsSucc)
                        throw ret.Error ?? new Exception();

                    if (downloadTask.DownloadStatus == DownloadStatus.Completed)
                    {
                        downloadTask.DownloadFileCompleted?.Invoke(downloadTask);

                        lock (locker)
                        {
                            _downloading.Remove(downloadTask);

                            if (_downloading.Count < _maximumCount)
                                TryRelease(_maximumCount - _downloading.Count);
                        }

                        return;
                    }
                }

                // 判断是否下载任务组
                if (downloadTask.Group != null)
                {
                    var total = downloadTask.Group.TotalBytesToReceive;

                    // 计算总字节数
                    foreach (var child in downloadTask.Group.Children)
                    {
                        if (child.DownloadStatus != DownloadStatus.Waiting || child.TotalBytesToReceive != 0)
                            continue;

                        var child_dc = child.CreateDownloadClient?.Invoke() ?? new HttpDownloadClient(child);
                        var ret = child_dc.GetFileSize();

                        if (!ret.IsSucc)
                        {
                            child.Error = ret.Error;
                            if (ret.Error != null)
                            {
                                var msg = ErrorTexts.HttpError(ret.Error, "下载文件");
                                child.ErrorMsg = msg;
                            }
                            child.DownloadStatus = DownloadStatus.Error;
                            child.DownloadFileCompleted?.Invoke(child);
                            // 任意一个获取失败，则取消整组下载
                            throw ret.Error ?? new Exception($"访问下载资源失败，Url：{child.Url}");
                        }

                        child.TotalBytesToReceive = ret.Value;
                        child.DownloadProgressChanged?.Invoke(downloadTask);
                    }

                    if (downloadTask.Group.TotalBytesToReceive != total)
                        downloadTask.Group.DownloadProgressChanged?.Invoke(downloadTask.Group);

                    if (downloadTask.Group.PreviewDownload != null)
                    {
                        var ret = downloadTask.Group.PreviewDownload.Invoke(downloadTask.Group);

                        if (!ret.IsSucc)
                            throw ret.Error ?? new Exception();
                        if (downloadTask.Group.DownloadStatus == DownloadStatus.Completed)
                        {
                            downloadTask.Group.DownloadFileCompleted?.Invoke(downloadTask.Group);

                            lock (locker)
                            {
                                Remove(downloadTask.Group);

                                if (_downloading.Count < _maximumCount)
                                    TryRelease(_maximumCount - _downloading.Count);
                            }

                            return;
                        }
                    }
                }

                lock (locker)
                {
                    if (!_downloading.ContainsKey(downloadTask))
                    {
                        throw new TaskCanceledException();
                    }

                    downloadClient = downloadTask.CreateDownloadClient?.Invoke() ?? new HttpDownloadClient(downloadTask);
                    downloadClient.DownloadProgressChanged -= OnDownloadProgressChanged;
                    downloadClient.DownloadProgressChanged += OnDownloadProgressChanged;
                    downloadClient.DownloadFileCompleted -= OnDownloadFileCompleted;
                    downloadClient.DownloadFileCompleted += OnDownloadFileCompleted;

                    _downloading[downloadTask] = downloadClient;
                }

                downloadTask.DownloadStatus = DownloadStatus.Downloading;
                downloadClient.BeginDownload();
            }
            catch (Exception ex)
            {
                Log.Info($"下载文件失败\tUrl：{downloadTask.Url}\tMsg：{ex.Message}");

                if (ex is TaskCanceledException)
                {
                    downloadTask.DownloadStatus = DownloadStatus.Cancelled;
                }
                else
                {
                    downloadTask.ErrorMsg = ErrorTexts.HttpError(ex, "下载文件");
                    Log.Error(downloadTask.Error = ex);
                    downloadTask.DownloadStatus = DownloadStatus.Error;
                }

                downloadTask.DownloadFileCompleted?.Invoke(downloadTask);

                lock (locker)
                {
                    if (downloadTask.Group != null)
                    {
                        downloadTask.Group.DownloadFileCompleted?.Invoke(downloadTask.Group);
                        Remove(downloadTask.Group);
                    }
                    else
                        _downloading.Remove(downloadTask);

                    if (_downloading.Count < _maximumCount)
                        TryRelease(_maximumCount - _downloading.Count);
                }

                downloadClient?.Dispose();
            }
        }

        /// <summary>
        /// 下载进度改变或下载完成
        /// </summary>
        private void OnDownloadProgressChanged((DownloadClientBase sender, long BytesReceived, long TotalBytesToReceive, int ProgressPercentage) e)
        {
            var downloadClient = e.sender;
            var downloadTask = downloadClient.DownloadTask;

            downloadTask.ProgressPercentage = e.ProgressPercentage;
            downloadTask.TotalBytesToReceive = e.TotalBytesToReceive;
            downloadTask.BytesReceived = e.BytesReceived;

            if (downloadTask.DownloadStatus == DownloadStatus.Waiting)
                downloadTask.DownloadStatus = DownloadStatus.Downloading;

            downloadTask.DownloadProgressChanged?.Invoke(downloadTask);
            downloadTask.Group?.DownloadProgressChanged?.Invoke(downloadTask.Group);
        }

        /// <summary>
        /// 下载完成或下载失败或下载取消
        /// </summary>
        private void OnDownloadFileCompleted((DownloadClientBase sender, Exception Error, bool Cancelled) e)
        {
            var downloadClient = e.sender;
            var downloadTask = downloadClient.DownloadTask;

            downloadClient.DownloadProgressChanged -= OnDownloadProgressChanged;
            downloadClient.DownloadFileCompleted -= OnDownloadFileCompleted;

            var groupStatus = downloadTask.Group?.DownloadStatus;

            try
            {
                downloadTask.EndTime = DateTime.Now;

                if (e.Cancelled)
                {
                    downloadTask.DownloadStatus = DownloadStatus.Cancelled;

                    // 取消整组
                    if (downloadTask.Group != null)
                    {
                        Remove(downloadTask.Group);
                        downloadTask.Group.DownloadFileCompleted?.Invoke(downloadTask.Group);
                    }
                }
                else if (e.Error != null)
                {
                    downloadTask.ErrorMsg = ErrorTexts.HttpError(e.Error, "下载文件");
                    downloadTask.Error = e.Error;
                    downloadTask.DownloadStatus = DownloadStatus.Error;

                    // 取消整组
                    if (downloadTask.Group != null)
                    {
                        Remove(downloadTask.Group);
                        downloadTask.Group.DownloadFileCompleted?.Invoke(downloadTask.Group);
                    }
                }
                else if (downloadTask.DownloadStatus != DownloadStatus.Completed)
                {
                    if (downloadTask.TotalBytesToReceive == 0 || downloadTask.TotalBytesToReceive != downloadTask.BytesReceived)
                    {
                        if (downloadTask.TotalBytesToReceive == 0)
                        {
                            var msg = ErrorTexts.Get(ErrorTextType.ConnectFailed, "下载文件");
                            downloadTask.ErrorMsg = msg;
                            downloadTask.Error = new WebException(msg, WebExceptionStatus.ConnectFailure);
                        }
                        else if (downloadTask.TotalBytesToReceive != downloadTask.BytesReceived)
                        {
                            var msg = ErrorTexts.Get(ErrorTextType.NetworkDisconnect);
                            downloadTask.ErrorMsg = msg;
                            downloadTask.Error = new WebException(msg, WebExceptionStatus.ConnectionClosed);
                        }

                        downloadTask.DownloadStatus = DownloadStatus.Error;

                        // 取消整组
                        if (downloadTask.Group != null)
                        {
                            Remove(downloadTask.Group);
                            downloadTask.Group.DownloadFileCompleted?.Invoke(downloadTask.Group);
                        }
                    }
                    else
                        downloadTask.DownloadStatus = DownloadStatus.Completed;
                }

                downloadTask.DownloadFileCompleted?.Invoke(downloadTask);

                if (downloadTask.Group != null && downloadTask.Group.DownloadFileCompleted != null && downloadTask.Group.DownloadStatus == DownloadStatus.Completed)
                    downloadTask.Group.DownloadFileCompleted.Invoke(downloadTask.Group);

                lock (locker)
                {
                    _downloading.Remove(downloadTask);

                    if (_downloading.Count < _maximumCount)
                        TryRelease(_maximumCount - _downloading.Count);
                }
            }
            catch (Exception ex)
            {
                try
                {
                    downloadTask.ErrorMsg = ErrorTexts.HttpError(ex, "下载文件");
                    downloadTask.Error = ex;
                    downloadTask.DownloadStatus = DownloadStatus.Error;
                    downloadTask.DownloadFileCompleted?.Invoke(downloadTask);

                    if (downloadTask.Group != null && downloadTask.Group.DownloadFileCompleted != null)
                        downloadTask.Group.DownloadFileCompleted.Invoke(downloadTask.Group);

                    lock (locker)
                    {
                        _downloading.Remove(downloadTask);

                        if (_downloading.Count < _maximumCount)
                            TryRelease(_maximumCount - _downloading.Count);

                        if (downloadTask.Group != null)
                        {
                            downloadTask.Group.DownloadFileCompleted?.Invoke(downloadTask.Group);
                            Remove(downloadTask.Group);
                        }
                    }
                }
                catch { }
            }
            finally
            {
                downloadClient.Dispose();

                if (downloadTask.Error != null)
                    Log.Error(downloadTask.Error, $"下载文件失败，Url：{downloadTask.Url}");
            }
        }

        private void TryRelease(int count = 1)
        {
            if (_semaphore == null)
                return;

            try
            {
                while (count-- > 0)
                {
                    _semaphore.Release();
                }
            }
            catch { }
        }

        public void GetCount(out int waitingCount, out int downloadingCount)
        {
            lock (locker)
            {
                waitingCount = _waiting.Count;
                downloadingCount = _downloading.Count;
            }
        }

        #endregion

        #region Property

        /// <summary>
        /// 下载器名称
        /// </summary>
        public string Name { get; }

        #endregion

        #region Field

        private object locker = new object();
        /// <summary>
        /// 信号量，限制同时下载数
        /// </summary>
        private Semaphore _semaphore;
        private int _maximumCount;
        /// <summary>
        /// 等待下载队列
        /// </summary>
        private List<DownloadTask> _waiting = new List<DownloadTask>();
        /// <summary>
        /// 正在下载队列
        /// </summary>
        private Dictionary<DownloadTask, DownloadClientBase> _downloading = new Dictionary<DownloadTask, DownloadClientBase>();
        private Thread _thread;

        #endregion
    }

    /// <summary>
    /// 下载任务
    /// </summary>
    public sealed class DownloadTask : BindableBase
    {
        private SpeedCalculator _speedCalculator;

        /// <summary>
        /// 下载任务
        /// </summary>
        /// <param name="downloadSpeedEnable">是否计算下载速度</param>
        public DownloadTask(bool downloadSpeedEnable = false)
        {
            if (downloadSpeedEnable)
            {
                DownloadProgressChanged += OnDownloadProgressChangedForDownloadSpeed;
                DownloadFileCompleted += OnDownloadFileCompletedForDownloadSpeed;
            }
        }

        /// <summary>
        /// 下载名称
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 下载编码
        /// </summary>
        public string Code { get; set; }
        /// <summary>
        /// 额外信息
        /// </summary>
        public object Extra { get; set; }
        /// <summary>
        /// 额外信息
        /// </summary>
        public Dictionary<String, String> Extras { get; set; }
        /// <summary>
        /// 下载链接
        /// </summary>
        public string Url { get; set; }
        /// <summary>
        /// 远程主机
        /// </summary>
        public string Host { get; set; }
        /// <summary>
        /// 端口号
        /// </summary>
        public int Port { get; set; }
        /// <summary>
        /// 用户名
        /// </summary>
        public string UserName { get; set; }
        /// <summary>
        /// 密码
        /// </summary>
        public string Password { get; set; }
        /// <summary>
        /// 保存路径
        /// </summary>
        public string FilePath { get; set; }
        /// <summary>
        /// 请求头
        /// </summary>
        public Dictionary<String, String> Headers { get; set; }

        /// <summary>
        /// 下载进度改变或下载完成
        /// </summary>
        public Action<DownloadTask> DownloadProgressChanged { get; set; }

        /// <summary>
        /// 进度百分比
        /// </summary>
        public int ProgressPercentage { get; set; }
        /// <summary>
        /// 总字节数
        /// </summary>
        public long TotalBytesToReceive { get; set; }
        /// <summary>
        /// 已接收字节数
        /// </summary>
        public long BytesReceived { get; set; }
        /// <summary>
        /// 下载速度 B/s
        /// </summary>
        public long? DownloadSpeed { get; private set; }
        /// <summary>
        /// 不显示下载速度
        /// </summary>
        public bool NoSpeed { get; set; }
        /// <summary>
        /// 固定百分比
        /// </summary>
        public double FixedPercentage { get; set; }
        /// <summary>
        /// 剩余时间（秒）
        /// </summary>
        public Double TimeRemaining { get; set; }

        /// <summary>
        /// 下载完成或下载失败或下载取消
        /// </summary>
        public Action<DownloadTask> DownloadFileCompleted { get; set; }
        /// <summary>
        /// 不触发事件的取消下载
        /// </summary>
        public Action<DownloadTask> Removed { get; set; }

        /// <summary>
        /// 是否已取消
        /// </summary>
        public bool Cancelled { get; set; }
        /// <summary>
        /// 发生的异常
        /// </summary>
        public Exception Error { get; set; }
        /// <summary>
        /// 错误消息
        /// </summary>
        public string ErrorMsg { get; set; }

        /// <summary>
        /// 下载状态
        /// </summary>
        public DownloadStatus DownloadStatus { get; set; }

        /// <summary>
        /// 下载前触发
        /// </summary>
        public Func<DownloadTask, ResultValue> PreviewDownload { get; set; }

        /// <summary>
        /// 所在下载任务组
        /// </summary>
        public DownloadTaskGroup Group { get; set; }

        /// <summary>
        /// 下载器
        /// </summary>
        public DownloadEngine DownloadEngine { get; set; }

        /// <summary>
        /// 自定义下载方式
        /// </summary>
        public Func<DownloadClientBase> CreateDownloadClient { get; set; }

        public Action<object> Retrying { get; set; }

        /// <summary>
        /// 开始时间
        /// </summary>
        public DateTime? BeginTime { get; set; }
        /// <summary>
        /// 结束时间
        /// </summary>
        public DateTime? EndTime { get; set; }
        /// <summary>
        /// 下载耗时
        /// </summary>
        public TimeSpan? Duration => EndTime - BeginTime;
        /// <summary>
        /// 平均下载速度
        /// </summary>
        public long? AverageDownloadSpeed => EndTime.HasValue ? ((long?)(BytesReceived / Duration?.TotalSeconds)) : null;


        private void OnDownloadProgressChangedForDownloadSpeed(DownloadTask obj)
        {
            if (DownloadStatus == DownloadStatus.Downloading && _speedCalculator == null && !NoSpeed)
            {
                _speedCalculator = new SpeedCalculator(() => BytesReceived, n =>
                {
                    if (DownloadStatus != DownloadStatus.Downloading)
                    {
                        if (_speedCalculator != null)
                        {
                            _speedCalculator.Dispose();
                            _speedCalculator = null;
                        }
                    }

                    DownloadSpeed = n;
                    if (n == 0)
                    {
                        TimeRemaining = Double.NaN;
                    }
                    else
                    {
                        var bytes_remaining = TotalBytesToReceive - BytesReceived;
                        TimeRemaining = bytes_remaining / n;
                    }
                    DownloadProgressChanged?.Invoke(this);
                });
                _speedCalculator.Start(BytesReceived);
            }

            RaisePropertyChanged(null);
        }

        private void OnDownloadFileCompletedForDownloadSpeed(DownloadTask obj)
        {
            if (_speedCalculator != null)
            {
                _speedCalculator.Dispose();
                _speedCalculator = null;
            }

            RaisePropertyChanged(null);
        }

        public void Retry()
        {
            DownloadStatus = DownloadStatus.Waiting;
            BytesReceived = 0;
            TotalBytesToReceive = 0;
            ProgressPercentage = 0;
            Error = null;
            ErrorMsg = null;
            Cancelled = false;

            Retrying?.Invoke(this);
            RaisePropertyChanged(null);
            DownloadEngine.Add(this);
        }

        public override string ToString()
        {
            var sb = new StringBuilder(nameof(DownloadTask));

            if (!String.IsNullOrEmpty(Name))
            {
                sb.Append(", name: " + Name);
            }
            if (!String.IsNullOrEmpty(Url))
            {
                sb.Append(", url: " + Url);
            }
            if (!String.IsNullOrEmpty(Host))
            {
                sb.Append(", host: " + Host);
            }
            if (Port != 0)
            {
                sb.Append(", port: " + Port);
            }
            if (!String.IsNullOrEmpty(UserName))
            {
                sb.Append(", userName: " + UserName);
            }
            if (!String.IsNullOrEmpty(Password))
            {
                sb.Append(", password: " + Password);
            }
            if (!String.IsNullOrEmpty(FilePath))
            {
                sb.Append(", filePath: " + FilePath);
            }
            sb.Append($", downloadStatus: {DownloadStatus}。");

            return sb.ToString();
        }
    }

    /// <summary>
    /// 下载任务组
    /// </summary>
    public sealed class DownloadTaskGroup : BindableBase
    {
        private SpeedCalculator _speedCalculator;

        /// <summary>
        /// 下载任务组
        /// </summary>
        /// <param name="downloadTasks">子下载任务</param>
        public DownloadTaskGroup(IEnumerable<DownloadTask> downloadTasks, bool downloadSpeedEnable = false)
        {
            Children = new List<DownloadTask>(downloadTasks);

            foreach (var downloadTask in downloadTasks)
            {
                downloadTask.Group = this;
            }

            if (downloadSpeedEnable)
            {
                DownloadProgressChanged += OnDownloadProgressChangedForDownloadSpeed;
                DownloadFileCompleted += OnDownloadFileCompletedForDownloadSpeed;
            }
        }

        /// <summary>
        /// 子下载任务
        /// </summary>
        public List<DownloadTask> Children { get; }
        /// <summary>
        /// 追加子任务
        /// </summary>
        public Action<DownloadTask> Appended { get; set; }

        /// <summary>
        /// 下载名称
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 下载编码
        /// </summary>
        public string Code { get; set; }
        /// <summary>
        /// 额外信息
        /// </summary>
        public object Extra { get; set; }

        /// <summary>
        /// 下载进度改变或下载完成
        /// </summary>
        public Action<DownloadTaskGroup> DownloadProgressChanged { get; set; }

        /// <summary>
        /// 进度百分比
        /// </summary>
        public int ProgressPercentage
        {
            get
            {
                var fixedSum = Children.Sum(q => q.FixedPercentage) / 100;
                var totalBytes = (long)(TotalBytesToReceive / (1 - fixedSum));

                var received = 0d;

                foreach (var child in Children)
                {
                    if (child.FixedPercentage == 0)
                    {
                        received += child.BytesReceived;
                    }
                    else
                    {
                        switch (child.DownloadStatus)
                        {
                            case DownloadStatus.Completed:
                                received += totalBytes * child.FixedPercentage / 100;
                                break;
                            case DownloadStatus.Downloading:
                                received += totalBytes * child.FixedPercentage / 100 * child.ProgressPercentage / 100;
                                break;
                        }
                    }
                }

                return totalBytes == 0 ? 0 : (int)(received * 100 / totalBytes);
            }
        }
        /// <summary>
        /// 总字节数
        /// </summary>
        public long TotalBytesToReceive => Children.Where(q => q.FixedPercentage == 0).Sum(q => q.TotalBytesToReceive);
        /// <summary>
        /// 已接收字节数
        /// </summary>
        public long BytesReceived => Children.Where(q => q.FixedPercentage == 0).Sum(q => q.BytesReceived);
        /// <summary>
        /// 下载速度 B/s
        /// </summary>
        public long? DownloadSpeed { get; private set; }
        /// <summary>
        /// 不显示下载速度
        /// </summary>
        public bool NoSpeed => CurrentDownloadTask.NoSpeed;
        /// <summary>
        /// 剩余时间（秒）
        /// </summary>
        public Double TimeRemaining { get; set; }

        /// <summary>
        /// 下载完成或下载失败或下载取消
        /// </summary>
        public Action<DownloadTaskGroup> DownloadFileCompleted { get; set; }

        /// <summary>
        /// 发生的异常
        /// </summary>
        public Exception Error => Children.FirstOrDefault(q => q.Error != null)?.Error;
        /// <summary>
        /// 错误消息
        /// </summary>
        public string ErrorMsg => Children.FirstOrDefault(q => q.Error != null)?.ErrorMsg;

        /// <summary>
        /// 下载状态
        /// </summary>
        public DownloadStatus DownloadStatus
        {
            get
            {
                if (Children.Any(q => q.DownloadStatus == DownloadStatus.Error))
                    return DownloadStatus.Error;
                if (Children.Any(q => q.DownloadStatus == DownloadStatus.Cancelled))
                    return DownloadStatus.Cancelled;
                if (Children.Any(q => q.DownloadStatus == DownloadStatus.Downloading))
                    return DownloadStatus.Downloading;
                if (Children.All(q => q.DownloadStatus == DownloadStatus.Waiting))
                    return DownloadStatus.Waiting;
                if (Children.Any(q => q.DownloadStatus == DownloadStatus.Waiting))
                    return DownloadStatus.Downloading;
                return DownloadStatus.Completed;
            }
        }

        public DownloadTask CurrentDownloadTask
        {
            get
            {
                while (Children.Count > 0)
                {
                    var downloadTask = GetDownloadTask();
                    if (downloadTask != null)
                    {
                        return downloadTask;
                    }
                    Thread.Yield();
                }
                return null;
            }
        }
        private DownloadTask GetDownloadTask()
        {
            var status = DownloadStatus;

            if (status == DownloadStatus.Waiting)
                return Children.FirstOrDefault(q => q.DownloadStatus == status);
            else if (status == DownloadStatus.Downloading)
                return Children.FirstOrDefault(q => q.DownloadStatus == status) ?? Children.FirstOrDefault(q => q.DownloadStatus == DownloadStatus.Waiting);
            else
                return Children.LastOrDefault(q => q.DownloadStatus == status) ?? Children.LastOrDefault();
        }

        /// <summary>
        /// 下载器
        /// </summary>
        public DownloadEngine DownloadEngine { get; set; }

        /// <summary>
        /// 下载前触发
        /// </summary>
        public Func<DownloadTaskGroup, ResultValue> PreviewDownload { get; set; }
        public Action<object> Retrying { get; set; }

        /// <summary>
        /// 开始时间
        /// </summary>
        public DateTime? BeginTime => Children.Where(q => q.BeginTime.HasValue).Min(q => q.BeginTime);
        /// <summary>
        /// 结束时间
        /// </summary>
        public DateTime? EndTime => Children.Where(q => q.EndTime.HasValue || q.BeginTime.HasValue).Max(q => q.EndTime.HasValue ? q.EndTime : q.BeginTime);
        /// <summary>
        /// 下载耗时
        /// </summary>
        public TimeSpan? Duration => EndTime - BeginTime;
        /// <summary>
        /// 平均下载速度
        /// </summary>
        public long? AverageDownloadSpeed => EndTime.HasValue ? ((long?)(BytesReceived / Duration?.TotalSeconds)) : null;

        private void OnDownloadProgressChangedForDownloadSpeed(DownloadTaskGroup obj)
        {
            if (DownloadStatus == DownloadStatus.Downloading && _speedCalculator == null)
            {
                _speedCalculator = new SpeedCalculator(() => BytesReceived, n =>
                {
                    if (DownloadStatus != DownloadStatus.Downloading)
                    {
                        if (_speedCalculator != null)
                        {
                            _speedCalculator.Dispose();
                            _speedCalculator = null;
                        }
                    }
                    if (NoSpeed)
                    {
                        DownloadSpeed = null;
                        TimeRemaining = Double.NaN;
                    }
                    else
                    {
                        DownloadSpeed = n;
                        if (n == 0)
                        {
                            TimeRemaining = Double.NaN;
                        }
                        else
                        {
                            var bytes_remaining = TotalBytesToReceive - BytesReceived;
                            TimeRemaining = bytes_remaining / n;
                        }
                    }
                    DownloadProgressChanged?.Invoke(this);
                });
                _speedCalculator.Start(BytesReceived);
            }

            RaisePropertyChanged(null);
        }

        private void OnDownloadFileCompletedForDownloadSpeed(DownloadTaskGroup obj)
        {
            if (_speedCalculator != null)
            {
                _speedCalculator.Dispose();
                _speedCalculator = null;
            }

            RaisePropertyChanged(null);
        }

        public void Retry()
        {
            foreach (var child in Children)
            {
                child.DownloadStatus = DownloadStatus.Waiting;
                child.BytesReceived = 0;
                child.TotalBytesToReceive = 0;
                child.ProgressPercentage = 0;
                child.Error = null;
                child.ErrorMsg = null;
                child.Cancelled = false;

                child.Retrying?.Invoke(child);
                child.RaisePropertyChanged(null);
            }

            Retrying?.Invoke(this);
            RaisePropertyChanged(null);
            DownloadEngine.Add(this);
        }

        public override string ToString()
        {
            var sb = new StringBuilder(nameof(DownloadTaskGroup));

            if (!String.IsNullOrEmpty(Name))
            {
                sb.Append(", name: " + Name);
            }
            sb.Append($", downloadStatus: {DownloadStatus}。");

            return sb.ToString();
        }
    }

    /// <summary>
    /// 下载进度监测器
    /// </summary>
    public sealed class DownloadProgressWatcher : BindableBase, IDisposable
    {
        private SpeedCalculator _speedCalculator;
        private readonly List<DownloadTask> _downloadTasks = new List<DownloadTask>();

        public DownloadProgressWatcher()
        {
            DownloadProgressChanged += OnDownloadProgressChangedForDownloadSpeed;
            DownloadFileCompleted += OnDownloadFileCompletedForDownloadSpeed;
        }

        public void AppendDownloadTask(DownloadTask downloadTask)
        {
            if (_downloadTasks.Contains(downloadTask))
            {
                return;
            }

            _downloadTasks.Add(downloadTask);

            if (downloadTask.TotalBytesToReceive == 0 && downloadTask != CurrentDownloadTask)
            {
                var client = downloadTask.CreateDownloadClient?.Invoke() ?? new HttpDownloadClient(downloadTask);
                var ret = client.GetFileSize();

                if (!ret.IsSucc)
                {
                    _downloadTasks.Remove(downloadTask);
                    return;
                }

                downloadTask.TotalBytesToReceive = ret.Value;
            }

            DownloadProgressChanged?.Invoke(this);

            downloadTask.DownloadProgressChanged -= OnDownloadTaskDownloadProgressChanged;
            downloadTask.DownloadProgressChanged += OnDownloadTaskDownloadProgressChanged;
            downloadTask.DownloadFileCompleted -= OnDownloadTaskDownloadFileCompleted;
            downloadTask.DownloadFileCompleted += OnDownloadTaskDownloadFileCompleted;
            downloadTask.Removed -= OnDownloadTaskRemoved;
            downloadTask.Removed += OnDownloadTaskRemoved;
        }

        public void AppendDownloadTaskGroup(DownloadTaskGroup group)
        {
            foreach (var downloadTask in group.Children)
            {
                AppendDownloadTask(downloadTask);
            }

            group.Appended -= AppendDownloadTask;
            group.Appended += AppendDownloadTask;
            group.DownloadFileCompleted -= OnDownloadTaskGroupDownloadFileCompleted;
            group.DownloadFileCompleted += OnDownloadTaskGroupDownloadFileCompleted;
        }


        public DownloadTask[] DownloadTasks => _downloadTasks.ToArray();
        /// <summary>
        /// 下载进度改变或下载完成
        /// </summary>
        public Action<DownloadProgressWatcher> DownloadProgressChanged { get; set; }

        /// <summary>
        /// 进度百分比
        /// </summary>
        public int ProgressPercentage
        {
            get
            {
                var fixedSum = _downloadTasks.Sum(q => q.FixedPercentage) / 100 / _downloadTasks.Count;
                var totalBytes = (long)(_downloadTasks.Sum(q => q.TotalBytesToReceive) / (1 - fixedSum));

                return totalBytes == 0 ? 0 : (int)(BytesReceived * 100 / totalBytes);
            }
        }
        /// <summary>
        /// 总字节数
        /// </summary>
        public long TotalBytesToReceive
        {
            get
            {
                var fixedSum = _downloadTasks.Sum(q => q.FixedPercentage) / 100 / _downloadTasks.Count;
                return (long)(_downloadTasks.Sum(q => q.TotalBytesToReceive) / (1 - fixedSum));
            }
        }
        /// <summary>
        /// 已接收字节数
        /// </summary>
        public long BytesReceived
        {
            get
            {
                var totalBytes = TotalBytesToReceive;
                var received = 0d;

                foreach (var child in _downloadTasks)
                {
                    if (child.FixedPercentage == 0)
                    {
                        received += child.BytesReceived;
                    }
                    else
                    {
                        switch (child.DownloadStatus)
                        {
                            case DownloadStatus.Completed:
                                received += totalBytes * child.FixedPercentage / 100 / _downloadTasks.Count;
                                break;
                            case DownloadStatus.Downloading:
                                received += totalBytes * child.FixedPercentage / 100 / _downloadTasks.Count * child.ProgressPercentage / 100;
                                break;
                        }
                    }
                }

                return (long)received;
            }
        }
        /// <summary>
        /// 下载速度 B/s
        /// </summary>
        public long? DownloadSpeed { get; private set; }

        /// <summary>
        /// 下载完成或下载失败或下载取消
        /// </summary>
        public Action<DownloadProgressWatcher> DownloadFileCompleted { get; set; }

        /// <summary>
        /// 下载状态
        /// </summary>
        public DownloadStatus DownloadStatus
        {
            get
            {
                var tasks = _downloadTasks.Where(q => q.DownloadStatus != DownloadStatus.Cancelled && q.DownloadStatus != DownloadStatus.Error).ToArray();

                if (tasks.Any(q => q.DownloadStatus == DownloadStatus.Downloading))
                    return DownloadStatus.Downloading;
                if (tasks.All(q => q.DownloadStatus == DownloadStatus.Waiting))
                    return DownloadStatus.Waiting;
                else
                    return DownloadStatus.Completed;
            }
        }

        public DownloadTask CurrentDownloadTask
        {
            get
            {
                while (_downloadTasks.Count > 0)
                {
                    var downloadTask = GetDownloadTask();
                    if (downloadTask != null)
                    {
                        return downloadTask;
                    }
                    Thread.Yield();
                }
                return null;
            }
        }
        private DownloadTask GetDownloadTask()
        {
            var status = DownloadStatus;

            if (status == DownloadStatus.Waiting)
                return _downloadTasks.FirstOrDefault(q => q.DownloadStatus == status);
            else if (status == DownloadStatus.Downloading)
                return _downloadTasks.FirstOrDefault(q => q.DownloadStatus == status) ?? _downloadTasks.FirstOrDefault(q => q.DownloadStatus == DownloadStatus.Waiting);
            else
                return _downloadTasks.LastOrDefault(q => q.DownloadStatus == status) ?? _downloadTasks.LastOrDefault();
        }

        private void OnDownloadTaskDownloadProgressChanged(DownloadTask downloadTask)
        {
            DownloadProgressChanged?.Invoke(this);
        }

        private void OnDownloadTaskDownloadFileCompleted(DownloadTask downloadTask)
        {
            downloadTask.DownloadFileCompleted -= OnDownloadTaskDownloadFileCompleted;

            if (_downloadTasks.All(q => q.DownloadStatus == DownloadStatus.Completed || q.DownloadStatus == DownloadStatus.Cancelled || q.DownloadStatus == DownloadStatus.Error))
            {
                DownloadFileCompleted?.Invoke(this);
            }
        }

        private void OnDownloadTaskRemoved(DownloadTask downloadTask)
        {
            downloadTask.Removed -= OnDownloadTaskRemoved;
            _downloadTasks.Remove(downloadTask);

            DownloadProgressChanged?.Invoke(this);
        }

        private void OnDownloadTaskGroupDownloadFileCompleted(DownloadTaskGroup group)
        {
            group.DownloadFileCompleted -= OnDownloadTaskGroupDownloadFileCompleted;
            group.Appended -= AppendDownloadTask;
        }

        private void OnDownloadProgressChangedForDownloadSpeed(DownloadProgressWatcher watcher)
        {
            if (DownloadStatus == DownloadStatus.Downloading && _speedCalculator == null && BytesReceived > 0)
            {
                _speedCalculator = new SpeedCalculator(() => BytesReceived, n =>
                {
                    if (DownloadStatus != DownloadStatus.Downloading)
                    {
                        if (_speedCalculator != null)
                        {
                            _speedCalculator.Dispose();
                            _speedCalculator = null;
                        }
                    }
                    DownloadSpeed = n;
                    DownloadProgressChanged?.Invoke(this);
                });
                _speedCalculator.Start(BytesReceived);
            }

            RaisePropertyChanged(null);
        }

        private void OnDownloadFileCompletedForDownloadSpeed(DownloadProgressWatcher watcher)
        {
            if (_speedCalculator != null)
            {
                _speedCalculator.Dispose();
                _speedCalculator = null;
            }

            RaisePropertyChanged(null);
        }

        public void Dispose()
        {
            if (_speedCalculator != null)
            {
                _speedCalculator.Dispose();
                _speedCalculator = null;
            }

            foreach (var downloadTask in _downloadTasks)
            {
                downloadTask.DownloadProgressChanged -= OnDownloadTaskDownloadProgressChanged;
                downloadTask.DownloadFileCompleted -= OnDownloadTaskDownloadFileCompleted;
                downloadTask.Removed -= OnDownloadTaskRemoved;

                var group = downloadTask.Group;

                if (group != null)
                {
                    group.Appended -= AppendDownloadTask;
                    group.DownloadFileCompleted -= OnDownloadTaskGroupDownloadFileCompleted;
                }
            }
        }
    }



    public abstract class DownloadClientBase : IDisposable
    {
        public DownloadClientBase(DownloadTask downloadTask)
        {
            _downloadTask = downloadTask;
        }

        public abstract ResultValue<long> GetFileSize();

        public abstract void BeginDownload();

        public abstract void BeginCancel();

        public abstract void Dispose();

        #region Property

        public DownloadTask DownloadTask => _downloadTask;

        public Action<(DownloadClientBase sender, long BytesReceived, long TotalBytesToReceive, int ProgressPercentage)> DownloadProgressChanged { get; set; }
        public Action<(DownloadClientBase sender, Exception Error, bool Cancelled)> DownloadFileCompleted { get; set; }

        #endregion

        #region Field

        private DownloadTask _downloadTask;

        #endregion
    }

    public class HttpDownloadClient : DownloadClientBase
    {
        public HttpDownloadClient(DownloadTask downloadTask) : base(downloadTask)
        {
            _webClient = new WebClientPro
            {
                UseDefaultCredentials = true,
                Encoding = Encoding.UTF8,
                Timeout = 60_000 * 60,
                KeepAlive = true
            };

            if (downloadTask.Headers != null)
            {
                foreach (var kv in downloadTask.Headers)
                {
                    _webClient.Headers.Add(kv.Key, kv.Value);
                }
            }

            _webClient.DownloadProgressChanged += OnDownloadProgressChanged;
            _webClient.DownloadFileCompleted += OnDownloadFileCompleted;
        }

        public override ResultValue<long> GetFileSize()
        {
            var result = new ResultValue<long>();

            HttpWebRequest req = null;
            HttpWebResponse rsp = null;

            try
            {
                req = (HttpWebRequest)HttpWebRequest.Create(DownloadTask.Url);
                req.Timeout = 10_000;
                req.Method = "HEAD";

                if (DownloadTask.Headers != null)
                {
                    foreach (var kv in DownloadTask.Headers)
                    {
                        if (kv.Key == "User-Agent")
                        {
                            req.UserAgent = kv.Value;
                            continue;
                        }

                        req.Headers.Add(kv.Key, kv.Value);
                    }
                }

                rsp = (HttpWebResponse)req.GetResponse();
                if (rsp.StatusCode != HttpStatusCode.OK || rsp.ContentLength == 0)
                {
                    throw new WebException($"访问下载资源失败，Url：{DownloadTask.Url}");
                }

                result.Value = rsp.ContentLength;
                result.IsSucc = true;
            }
            catch (Exception ex)
            {
                result.Error = ex;
                result.Msg = ErrorTexts.HttpError(ex, $"访问下载资源失败，Url：{DownloadTask.Url}", out result.errorTextType);
            }
            finally
            {
                rsp?.Close();
                req?.Abort();

                if (!result.IsSucc)
                {
                    if (result.Error != null)
                        Log.Error(result.Error, result.Msg);
                    else
                        Log.Info(result.Msg);
                }
            }

            return result;
        }

        public override void BeginDownload()
        {
            FileHelper.DeleteFile(DownloadTask.FilePath);
            FileHelper.CreateDirectory(Path.GetDirectoryName(DownloadTask.FilePath));

            var uri = new Uri(DownloadTask.Url, UriKind.RelativeOrAbsolute);
            _webClient.DownloadFileAsync(uri, DownloadTask.FilePath);
        }

        public override void BeginCancel()
        {
            _webClient.CancelAsync();

            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;

                DownloadFileCompleted?.Invoke((this, null, true));
            }
        }

        public override void Dispose()
        {
            _webClient.Dispose();
        }

        private void OnDownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
        {
            DownloadProgressChanged?.Invoke((this, DownloadTask.BytesReceived = e.BytesReceived, DownloadTask.TotalBytesToReceive = e.TotalBytesToReceive, e.ProgressPercentage));
        }

        private void OnDownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                var web_ex = e.Error as WebException;
                if (web_ex != null && web_ex.Response is HttpWebResponse http_res && http_res.StatusCode == HttpStatusCode.InternalServerError)
                {
                    _cts.TryCancel();
                    _cts = new CancellationTokenSource();
                    var token = _cts.Token;
                    token.Register(() => SharedTimer.Unsubscribe(new Action<CancellationToken>(ReDownload)));

                    try
                    {
                        var stream = web_ex.Response.GetResponseStream();
                        using (var sr = new StreamReader(stream, Encoding.UTF8))
                        {
                            var res_content = sr.ReadToEnd();
                            if (Json.TryParse(res_content, out SaasResult res) && res.code == 201)
                            {
                                Log.Info(res.msg);
                                SharedTimer.Subscribe(30, 30, new Action<CancellationToken>(ReDownload), token);
                                return;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Error(ex, ErrorTexts.HttpError(ex, "下载"));
                    }
                }
            }
            DownloadFileCompleted?.Invoke((this, e.Error, e.Cancelled));
        }

        private void ReDownload(CancellationToken token)
        {
            SharedTimer.Unsubscribe(new Action<CancellationToken>(ReDownload));

            if (!token.IsCancellationRequested)
            {
                BeginDownload();
            }
        }

        #region Field

        private WebClient _webClient;
        private CancellationTokenSource _cts;

        #endregion
    }

    public class FtpDownloadClient : DownloadClientBase
    {
        public FtpDownloadClient(DownloadTask downloadTask) : base(downloadTask)
        {
            _ftp = (FtpWebRequest)FtpWebRequest.Create(new Uri(downloadTask.Url, UriKind.RelativeOrAbsolute));
            _ftp.Credentials = new NetworkCredential(downloadTask.UserName, downloadTask.Password);
            _ftp.Method = WebRequestMethods.Ftp.DownloadFile;
            _ftp.UseBinary = true;
        }

        public override ResultValue<long> GetFileSize()
        {
            var result = new ResultValue<long>();
            var ftp = (FtpWebRequest)FtpWebRequest.Create(new Uri(DownloadTask.Url));

            try
            {
                ftp.Credentials = new NetworkCredential(DownloadTask.UserName, DownloadTask.Password);
                ftp.UseBinary = true;
                ftp.Method = WebRequestMethods.Ftp.GetFileSize;
                var res = ftp.GetResponse();

                if (res.ContentLength == 0)
                    throw new Exception($"访问下载资源失败，Url：{DownloadTask.Url}");

                result.Value = res.ContentLength;
                result.IsSucc = true;
            }
            catch (Exception ex)
            {
                result.Error = ex;
                result.Msg = ErrorTexts.FtpError(ex, "下载文件", out result.errorTextType);
            }
            finally
            {
                ftp.Abort();

                if (!result.IsSucc)
                {
                    if (result.Error != null)
                        Log.Error(result.Error, result.Msg);
                    else
                        Log.Info(result.Msg);
                }
            }

            return result;
        }

        public override void BeginDownload()
        {
            _cts.TryCancel();
            _cts = new CancellationTokenSource();

            ThreadPool.QueueUserWorkItem(n =>
            {
                var token = (CancellationToken)n;

                try
                {
                    FileHelper.DeleteFile(DownloadTask.FilePath);
                    FileHelper.CreateDirectory(Path.GetDirectoryName(DownloadTask.FilePath));

                    var buffLength = 1024;
                    var buff = new byte[buffLength];

                    using (var stream = new FileStream(DownloadTask.FilePath, FileMode.CreateNew, FileAccess.Write))
                    {
                        using (var reqStream = _ftp.GetRequestStream())
                        {
                            var contentLen = 0;
                            DownloadTask.TotalBytesToReceive = reqStream.Length;
                            DownloadTask.BytesReceived = 0L;

                            do
                            {
                                contentLen = reqStream.Read(buff, 0, buffLength);
                                stream.Write(buff, 0, contentLen);

                                DownloadTask.BytesReceived += contentLen;

                                DownloadProgressChanged?.Invoke((this, DownloadTask.BytesReceived, reqStream.Length, (int)(DownloadTask.BytesReceived * 100d / reqStream.Length)));
                            }
                            while (contentLen != 0 && !token.IsCancellationRequested);
                        }
                    }

                    DownloadFileCompleted?.Invoke((this, null, token.IsCancellationRequested));
                }
                catch (Exception ex)
                {
                    DownloadFileCompleted?.Invoke((this, ex, token.IsCancellationRequested));
                }
            }, _cts.Token);
        }

        public override void BeginCancel()
        {
            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        public override void Dispose()
        {
            _ftp.Abort();

            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        #region Field

        private FtpWebRequest _ftp;
        private CancellationTokenSource _cts;

        #endregion
    }

    public class SftpDownloadClient : DownloadClientBase
    {
        public SftpDownloadClient(DownloadTask downloadTask) : base(downloadTask)
        {
            _sftp = new SftpClient(downloadTask.Host, downloadTask.Port, downloadTask.UserName, downloadTask.Password);
        }

        public override ResultValue<long> GetFileSize()
        {
            var result = new ResultValue<long>();

            _sftp = new SftpClient(DownloadTask.Host, DownloadTask.Port, DownloadTask.UserName, DownloadTask.Password);

            try
            {
                var folder = Path.GetDirectoryName(DownloadTask.Url);
                var fileName = Path.GetFileName(DownloadTask.Url);

                _sftp.Connect();
                var files = _sftp.ListDirectory(folder);
                var file = files.FirstOrDefault(q => q.Name == fileName);

                if (file == null || file.Length == 0)
                    throw new Exception($"访问下载资源失败，Url：{DownloadTask.Url}");

                result.Value = DownloadTask.TotalBytesToReceive = file.Length;
                result.IsSucc = true;
            }
            catch (Exception ex)
            {
                result.Error = ex;
                result.Msg = ErrorTexts.FtpError(ex, "下载文件", out result.errorTextType);
            }
            finally
            {
                _sftp.Dispose();

                if (!result.IsSucc)
                {
                    if (result.Error != null)
                        Log.Error(result.Error, result.Msg);
                    else
                        Log.Info(result.Msg);
                }
            }

            return result;
        }

        public override void BeginDownload()
        {
            _cts?.TryCancel();
            _cts = new CancellationTokenSource();

            ThreadPool.QueueUserWorkItem(n =>
            {
                var token = (CancellationToken)n;

                try
                {
                    _sftp.Connect();

                    FileHelper.DeleteFile(DownloadTask.FilePath);
                    FileHelper.CreateDirectory(Path.GetDirectoryName(DownloadTask.FilePath));

                    using (var stream = new FileStream(DownloadTask.FilePath, FileMode.CreateNew, FileAccess.Write))
                    {
                        if (DownloadTask.TotalBytesToReceive == 0)
                        {
                            var ret = GetFileSize();

                            if (!ret.IsSucc)
                            {
                                DownloadFileCompleted?.Invoke((this, ret.Error, token.IsCancellationRequested));
                                return;
                            }

                            DownloadTask.TotalBytesToReceive = ret.Value;
                        }

                        _sftp.DownloadFile(DownloadTask.Url, stream, m => { DownloadTask.BytesReceived = (long)m; DownloadProgressChanged?.Invoke((this, DownloadTask.BytesReceived, DownloadTask.TotalBytesToReceive, (int)(m * 100d / DownloadTask.TotalBytesToReceive))); });

                        if (DownloadTask.BytesReceived != DownloadTask.TotalBytesToReceive)
                        {
                            DownloadTask.BytesReceived = DownloadTask.TotalBytesToReceive;
                            DownloadProgressChanged?.Invoke((this, DownloadTask.BytesReceived, DownloadTask.TotalBytesToReceive, 100));
                        }
                    }

                    DownloadFileCompleted?.Invoke((this, null, token.IsCancellationRequested));
                }
                catch (Exception ex)
                {
                    DownloadFileCompleted?.Invoke((this, ex, token.IsCancellationRequested));
                }
            }, _cts.Token);
        }

        public override void BeginCancel()
        {
            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        public override void Dispose()
        {
            _sftp.Dispose();

            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        #region Field

        private SftpClient _sftp;
        private CancellationTokenSource _cts;

        #endregion
    }

    public class CustomDownloadClient : DownloadClientBase
    {
        public CustomDownloadClient(DownloadTask downloadTask) : base(downloadTask) { }

        public override ResultValue<long> GetFileSize() => GetFileSizeCalled == null ? ResultValue<long>.Succeed(0) : GetFileSizeCalled.Invoke();

        public override void BeginDownload()
        {
            if (BeginDownloadCalled == null)
            {
                DownloadTask.DownloadStatus = DownloadStatus.Completed;
                DownloadFileCompleted?.Invoke((this, null, false));
            }
            else
            {
                _cts?.TryCancel();
                _cts = new CancellationTokenSource();
                BeginDownloadCalled.Invoke(this, _cts.Token);
            }
        }

        public override void BeginCancel()
        {
            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }

            if (BeginCancelCalled != null)
            {
                BeginCancelCalled.Invoke(this);
            }
            else
            {
                DownloadFileCompleted?.Invoke((this, null, true));
            }
        }

        public override void Dispose() => DisposeCalled?.Invoke(this);

        #region Property

        public Func<ResultValue<long>> GetFileSizeCalled { get; set; }

        public Action<CustomDownloadClient, CancellationToken> BeginDownloadCalled { get; set; }

        public Action<CustomDownloadClient> BeginCancelCalled { get; set; }

        public Action<CustomDownloadClient> DisposeCalled { get; set; }

        #endregion

        #region Field

        private CancellationTokenSource _cts;

        #endregion
    }

    /// <summary>
    /// 星原断点下载
    /// </summary>
    public class HttpRangeDownloadClient : DownloadClientBase
    {
        public HttpRangeDownloadClient(DownloadTask downloadTask) : base(downloadTask)
        {
            _webClient = new WebClientPro
            {
                UseDefaultCredentials = true,
                Encoding = Encoding.UTF8,
                Timeout = 60_000 * 60,
                KeepAlive = true
            };

            if (downloadTask.Headers != null)
            {
                foreach (var kv in downloadTask.Headers)
                {
                    _webClient.Headers.Add(kv.Key, kv.Value);
                }
            }

            _webClient.DownloadProgressChanged += OnDownloadProgressChanged;
            _webClient.DownloadFileCompleted += OnDownloadFileCompleted;
        }

        public override ResultValue<long> GetFileSize()
        {
            var result = new ResultValue<long>();

            HttpWebRequest req = null;
            HttpWebResponse rsp = null;

            try
            {
                req = (HttpWebRequest)HttpWebRequest.Create(DownloadTask.Url);
                req.Timeout = 10_000;
                req.Method = "HEAD";

                if (DownloadTask.Headers != null)
                {
                    foreach (var kv in DownloadTask.Headers)
                    {
                        if (kv.Key == "User-Agent")
                        {
                            req.UserAgent = kv.Value;
                            continue;
                        }

                        req.Headers.Add(kv.Key, kv.Value);
                    }
                }

                rsp = (HttpWebResponse)req.GetResponse();
                if (rsp.StatusCode != HttpStatusCode.OK || rsp.ContentLength == 0)
                {
                    throw new WebException($"访问下载资源失败，Url：{DownloadTask.Url}");
                }
                result.Value = rsp.ContentLength;

                var range = rsp.Headers.Get("Content-Range");
                if (range != null)
                {
                    var total = range.Split('/').LastOrDefault().TryConvert<long>(out var succee);
                    if (succee)
                    {
                        result.Value = total;
                    }
                }
                result.IsSucc = true;
            }
            catch (Exception ex)
            {
                result.Msg = ErrorTexts.HttpError(ex, $"访问下载资源失败，Url：{DownloadTask.Url}", out result.errorTextType);
                result.Error = ex;
            }
            finally
            {
                rsp?.Close();
                req?.Abort();

                if (!result.IsSucc)
                {
                    if (result.Error != null)
                        Log.Error(result.Error, result.Msg);
                    else
                        Log.Info(result.Msg);
                }
            }

            return result;
        }

        public override void BeginDownload()
        {
            FileHelper.DeleteFile(DownloadTask.FilePath);
            FileHelper.CreateDirectory(Path.GetDirectoryName(DownloadTask.FilePath));

            if (DownloadTask.TotalBytesToReceive == 0)
            {
                var ret = GetFileSize();
                if (!ret.IsSucc || ret.Value == 0)
                {
                    DownloadFileCompleted?.Invoke((this, ret.Error ?? new Exception($"访问下载资源失败，Url：{DownloadTask.Url}"), false));
                    return;
                }
                DownloadTask.TotalBytesToReceive = ret.Value;
            }

            DownloadTask.DownloadStatus = DownloadStatus.Downloading;

            var downloadingFile = new FileInfo(DownloadTask.FilePath + ".downloading");
            var downloadedSize = downloadingFile.Exists ? downloadingFile.Length : 0L;
            var chunkSize = Math.Min(ChunkSize, DownloadTask.TotalBytesToReceive - downloadedSize);
            _webClient.From = downloadedSize;
            _webClient.To = downloadedSize + chunkSize;
            var chunkFile = new FileInfo(DownloadTask.FilePath + ".chunk");
            if (chunkFile.Exists)
            {
                FileHelper.DeleteFile(chunkFile.FullName);
            }

            var uri = new Uri(DownloadTask.Url + $"&fileName={chunkFile.Name}", UriKind.RelativeOrAbsolute);
            Log.Info(uri.OriginalString);
            _webClient.DownloadFileAsync(uri, chunkFile.FullName);
        }

        public override void BeginCancel()
        {
            _webClient.CancelAsync();

            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;

                DownloadFileCompleted?.Invoke((this, null, true));
            }
        }

        public override void Dispose()
        {
            _webClient.Dispose();
        }

        private void OnDownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
        {
            if (DownloadTask.TotalBytesToReceive < e.TotalBytesToReceive)
            {
                DownloadTask.TotalBytesToReceive = e.TotalBytesToReceive;
            }
            DownloadTask.BytesReceived = Math.Min(_webClient.From + e.BytesReceived, DownloadTask.TotalBytesToReceive);
            DownloadTask.ProgressPercentage = (int)(DownloadTask.BytesReceived * 100.0 / DownloadTask.TotalBytesToReceive);
            DownloadProgressChanged?.Invoke((this, DownloadTask.BytesReceived, DownloadTask.TotalBytesToReceive, DownloadTask.ProgressPercentage));
        }

        private void OnDownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                var web_ex = e.Error as WebException;
                if (web_ex != null && web_ex.Response is HttpWebResponse http_res && http_res.StatusCode == HttpStatusCode.InternalServerError)
                {
                    _cts.TryCancel();
                    _cts = new CancellationTokenSource();
                    var token = _cts.Token;
                    token.Register(() => SharedTimer.Unsubscribe(new Action<CancellationToken>(ReDownload)));

                    try
                    {
                        var stream = web_ex.Response.GetResponseStream();
                        using (var sr = new StreamReader(stream, Encoding.UTF8))
                        {
                            var res_content = sr.ReadToEnd();
                            if (Json.TryParse(res_content, out SaasResult res) && res.code == 201)
                            {
                                Log.Info(res.msg);
                                SharedTimer.Subscribe(30, 30, new Action<CancellationToken>(ReDownload), token);
                                return;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Error(ex, ErrorTexts.HttpError(ex, "下载"));
                    }
                }
            }
            else if (!e.Cancelled)
            {
                // 下载成功，合并分包
                var chunkFile = new FileInfo(DownloadTask.FilePath + ".chunk");
                var downloadingFile = new FileInfo(DownloadTask.FilePath + ".downloading");
                var margeFlag = false;
                if (!downloadingFile.Exists)
                {
                    margeFlag = FileHelper.MoveFile(chunkFile.FullName, downloadingFile.FullName);
                }
                else
                {
                    margeFlag = FileHelper.MargeFiles(downloadingFile.FullName, chunkFile.FullName);
                }
                if (!margeFlag)
                {
                    DownloadFileCompleted?.Invoke((this, new Exception("分包下载，合并下载文件失败！"), false));
                    return;
                }
                if (DownloadTask.BytesReceived == DownloadTask.TotalBytesToReceive)
                {
                    FileHelper.MoveFile(downloadingFile.FullName, DownloadTask.FilePath);
                }
                else
                {
                    // 继续下载剩余分包
                    BeginDownload();
                    return;
                }
            }
            DownloadFileCompleted?.Invoke((this, e.Error, e.Cancelled));
        }

        private void ReDownload(CancellationToken token)
        {
            SharedTimer.Unsubscribe(new Action<CancellationToken>(ReDownload));

            if (!token.IsCancellationRequested)
            {
                BeginDownload();
            }
        }

        #region Property

        /// <summary>
        /// 分包大小，默认30M
        /// </summary>
        public long ChunkSize { get; set; } = 1024 * 1024 * 30;

        #endregion

        #region Field

        private WebClientPro _webClient;
        private CancellationTokenSource _cts;

        #endregion
    }
}

 

上传器关键源码：

using Gnt.DTOs;
using Gnt.Events;
using Gnt.Events.PubSubEvents;
using Gnt.Extensions;
using Gnt.Ioc;
using Gnt.Mvvm;
using Renci.SshNet;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Gnt.Utils
{
    /// <summary>
    /// 上传器
    /// </summary>
    public sealed class UploadEngine : IDisposable
    {
        #region Static

        /// <summary>
        /// 已创建上传器
        /// </summary>
        private static Dictionary<string, UploadEngine> _uploadEngines = new Dictionary<string, UploadEngine>();

        /// <summary>
        /// 创建上传器
        /// </summary>
        /// <param name="name">上传器名称</param>
        /// <param name="maximumCount">最大同时上传数</param>
        /// <param name="createdNew">是否创建了新的</param>
        /// <returns></returns>
        public static UploadEngine Create(string name, int maximumCount, out bool createdNew)
        {
            lock (_uploadEngines)
            {
                createdNew = false;

                if (_uploadEngines.TryGetValue(name, out UploadEngine uploadEngine))
                    return uploadEngine;

                uploadEngine = new UploadEngine(name, maximumCount);
                _uploadEngines.Add(name, uploadEngine);

                createdNew = true;
                return uploadEngine;
            }
        }

        /// <summary>
        /// 获取上传器
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static UploadEngine Get(string name)
        {
            lock (_uploadEngines)
            {
                if (_uploadEngines.TryGetValue(name, out UploadEngine uploadEngine))
                    return uploadEngine;
                return null;
            }
        }

        #endregion

        /// <summary>
        /// 上传器
        /// </summary>
        /// <param name="name">上传器名称</param>
        /// <param name="maximumCount">最大同时上传数</param>
        private UploadEngine(string name, int maximumCount)
        {
            Name = name;
            _maximumCount = maximumCount;
            _semaphore = new Semaphore(maximumCount, maximumCount);
        }

        #region Method

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            lock (locker)
            {
                foreach (var item in _waiting.ToArray())
                {
                    Remove(item);
                }
                foreach (var item in _uploading.Keys.ToArray())
                {
                    Remove(item);
                }
            }

            lock (_uploadEngines)
            {
                if (_semaphore != null)
                {
                    _semaphore.Dispose();
                    _semaphore = null;
                }

                _uploadEngines.Remove(Name);
            }
        }

        /// <summary>
        /// 加入上传任务
        /// </summary>
        /// <param name="uploadTask"></param>
        public void Add(UploadTask uploadTask)
        {
            lock (locker)
            {
                if (_uploading.ContainsKey(uploadTask) || _waiting.Contains(uploadTask))
                    return;

                _waiting.Add(uploadTask);
                uploadTask.UploadEngine = this;

                if (_thread == null)
                {
                    // 启动轮询线程
                    _thread = new Thread(new ThreadStart(Run)) { IsBackground = true };
                    _thread.Start();
                }
            }
        }

        /// <summary>
        /// 加入上传任务组
        /// </summary>
        /// <param name="multipleUploadTask"></param>
        public void Add(UploadTaskGroup uploadTaskGroup)
        {
            lock (locker)
            {
                foreach (var uploadTask in uploadTaskGroup.Children)
                {
                    Add(uploadTask);
                }
                uploadTaskGroup.UploadEngine = this;
            }
        }

        /// <summary>
        /// 移除上传任务
        /// </summary>
        /// <param name="uploadTask"></param>
        public void Remove(UploadTask uploadTask)
        {
            UploadClientBase uploadClient = null;

            lock (locker)
            {
                if (_uploading.TryGetValue(uploadTask, out uploadClient))
                    _uploading.Remove(uploadTask);
                else if (_waiting.Remove(uploadTask))
                {
                    uploadTask.UploadStatus = UploadStatus.Cancelled;
                    uploadTask.UploadDataCompleted?.Invoke(uploadTask);

                    if (uploadTask.Group != null)
                        uploadTask.Group.UploadDataCompleted?.Invoke(uploadTask.Group);
                }
            }

            // 取消上传
            uploadClient?.BeginCancel();
        }

        /// <summary>
        /// 移除指定上传任务
        /// </summary>
        /// <param name="predicate"></param>
        public void Remove(Func<UploadTask, bool> predicate)
        {
            lock (locker)
            {
                foreach (var item in _waiting.Where(predicate).ToArray())
                {
                    Remove(item);
                }

                foreach (var item in _uploading.Keys.Where(predicate).ToArray())
                {
                    Remove(item);
                }
            }
        }

        /// <summary>
        /// 移除指定上传任务组
        /// </summary>
        /// <param name="predicate"></param>
        public void Remove(Func<UploadTaskGroup, bool> predicate)
        {
            lock (locker)
            {
                foreach (var item in _waiting.Where(q => q.Group != null && predicate.Invoke(q.Group)).ToArray())
                {
                    Remove(item);
                }

                foreach (var item in _uploading.Keys.Where(q => q.Group != null && predicate.Invoke(q.Group)).ToArray())
                {
                    Remove(item);
                }
            }
        }

        /// <summary>
        /// 移除上传任务组
        /// </summary>
        /// <param name="uploadTaskGroup"></param>
        public void Remove(UploadTaskGroup uploadTaskGroup)
        {
            lock (locker)
            {
                foreach (var uploadTask in uploadTaskGroup.Children)
                {
                    Remove(uploadTask);
                }
            }
        }

        /// <summary>
        /// 移除等待中的上传任务，并且不触发事件
        /// </summary>
        /// <param name="uploadTask"></param>
        public bool RemoveWaitingTask(UploadTask uploadTask)
        {
            lock (locker)
            {
                if (_waiting.Remove(uploadTask))
                {
                    uploadTask.UploadStatus = UploadStatus.Cancelled;

                    if (uploadTask.Group != null)
                    {
                        var group = uploadTask.Group;

                        uploadTask.Group = null;
                        group.Children.Remove(uploadTask);
                    }

                    uploadTask.Removed?.Invoke(uploadTask);

                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// 插入上传任务
        /// </summary>
        /// <param name="uploadTask"></param>
        public void Unshift(UploadTask uploadTask)
        {
            lock (locker)
            {
                _waiting.Insert(0, uploadTask);
                uploadTask.UploadEngine = this;

                if (uploadTask.Group != null)
                {
                    uploadTask.Group.Children.Add(uploadTask);
                    uploadTask.Group.Appended?.Invoke(uploadTask);
                }
            }
        }

        /// <summary>
        /// 插入上传任务
        /// </summary>
        public void UnshiftBefore(UploadTask newUploadTask, UploadTask beforeUploadTask)
        {
            lock (locker)
            {
                var index = _waiting.IndexOf(beforeUploadTask);
                _waiting.Insert(index, newUploadTask);
                newUploadTask.UploadEngine = this;

                if (newUploadTask.Group != null)
                {
                    index = newUploadTask.Group.Children.IndexOf(beforeUploadTask);
                    if (index == -1)
                    {
                        newUploadTask.Group.Children.Add(newUploadTask);
                    }
                    else
                    {
                        newUploadTask.Group.Children.Insert(index, newUploadTask);
                    }
                    newUploadTask.Group.Appended?.Invoke(newUploadTask);
                }
            }
        }

        /// <summary>
        /// 获取上传任务
        /// </summary>
        /// <param name="status">上传状态   0:全部|1:等待上传|2:上传中</param>
        /// <returns></returns>
        public UploadTask[] GetUploadTasks(int status = 0)
        {
            lock (locker)
            {
                switch (status)
                {
                    case 1:
                        return _waiting.ToArray();
                    case 2:
                        return _uploading.Keys.ToArray();
                    default:
                        var list = new List<UploadTask>(_waiting.Count + _uploading.Count);
                        list.AddRange(_waiting);
                        list.AddRange(_uploading.Keys);
                        return list.ToArray();
                }
            }
        }

        /// <summary>
        /// 获取上传任务组
        /// </summary>
        /// <param name="status">上传状态   0:全部|1:等待上传|2:上传中</param>
        /// <returns></returns>
        public UploadTaskGroup[] GetUploadTaskGroups(int status = 0)
        {
            lock (locker)
            {
                var list = new List<UploadTaskGroup>();
                list.AddRange(_waiting.Where(q => q.Group != null).Select(q => q.Group));
                list.AddRange(_uploading.Keys.Where(q => q.Group != null).Select(q => q.Group));
                var query = list.Distinct();

                switch (status)
                {
                    case 1:
                        return query.Where(q => q.UploadStatus == UploadStatus.Waiting).ToArray();
                    case 2:
                        return query.Where(q => q.UploadStatus == UploadStatus.Uploading).ToArray();
                    default:
                        return query.ToArray();
                }
            }
        }

        public bool AnyTask(Func<UploadTask, bool> predicate = null)
        {
            return (predicate == null ? _waiting.Any() : _waiting.Any(predicate)) || (predicate == null ? _uploading.Any() : _uploading.Keys.Any(predicate));
        }

        public Task<bool> AnyTaskGroupAsync(Func<UploadTaskGroup, bool> predicate)
        {
            return Task.Run(() => AnyTaskGroup(predicate));
        }

        public bool AnyTaskGroup(Func<UploadTaskGroup, bool> predicate)
        {
            return _waiting.Where(q => q.Group != null).Select(q => q.Group).Any(predicate) || _uploading.Keys.Where(q => q.Group != null).Select(q => q.Group).Any(predicate);
        }

        /// <summary>
        /// 查询第一个符合描述的上传任务
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public UploadTask GetUploadTask(Func<UploadTask, bool> predicate)
        {
            lock (locker)
            {
                return _waiting.FirstOrDefault(predicate) ?? _uploading.Keys.FirstOrDefault(predicate);
            }
        }

        /// <summary>
        /// 查询第一个符合描述的上传任务组
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public UploadTaskGroup GetUploadTaskGroup(Func<UploadTaskGroup, bool> predicate)
        {
            lock (locker)
            {
                var group = _waiting.Where(q => q.Group != null).Select(q => q.Group).FirstOrDefault(predicate);

                if (group != null)
                    return group;

                return _uploading.Keys.Where(q => q.Group != null).Select(q => q.Group).FirstOrDefault(predicate);
            }
        }

        /// <summary>
        /// 查询第一个符合描述的上传任务
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public UploadTask GetOrAdd(Func<UploadTask, bool> predicate, Func<UploadTask> create)
        {
            lock (locker)
            {
                var task = _waiting.FirstOrDefault(predicate);

                if (task != null)
                    return task;

                task = _uploading.Keys.FirstOrDefault(predicate);

                if (task != null)
                    return task;

                task = create.Invoke();

                if (task != null)
                    Add(task);

                return task;
            }
        }

        /// <summary>
        /// 查询第一个符合描述的上传任务组
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public UploadTaskGroup GetOrAdd(Func<UploadTaskGroup, bool> predicate, Func<UploadTaskGroup> create)
        {
            lock (locker)
            {
                var group = _waiting.Where(q => q.Group != null).Select(q => q.Group).FirstOrDefault(predicate);

                if (group != null)
                    return group;

                group = _uploading.Keys.Where(q => q.Group != null).Select(q => q.Group).FirstOrDefault(predicate);

                if (group != null)
                    return group;

                group = create.Invoke();

                if (group != null)
                    Add(group);

                return group;
            }
        }

        /// <summary>
        /// 开始轮询等待上传队列
        /// </summary>
        private void Run()
        {
            try
            {
                ContainerLocator.Current.Resolve<IEventAggregator>().GetEvent<IsIdleEvent>().Publish((this, false));

                while (_semaphore != null)
                {
                    var ret = _semaphore.WaitOne(10000);

                    lock (locker)
                    {
                        if (!ret)
                        {
                            if (_uploading.Count < _maximumCount)
                            {
                                // 到这里一定是代码出错了
                                Log.Debug($"等待信号失败，强制释放{_maximumCount - _uploading.Count}信号量");

                                try
                                {
                                    TryRelease(_maximumCount - _uploading.Count);
                                }
                                catch { }
                            }
                            else if (_waiting.Count == 0 && _uploading.Count == 0)
                            {
                                _thread = null;
                                break;
                            }

                            continue;
                        }

                        if (_waiting.Count == 0 && _uploading.Count == 0)
                        {
                            _thread = null;
                            TryRelease();   // 耗费了一个信号，要释放一个
                            break;
                        }

                        if (_waiting.Count > 0)
                        {
                            var uploadTask = _waiting.First();
                            _waiting.Remove(uploadTask);
                            _uploading.Add(uploadTask, null);

                            ThreadPool.QueueUserWorkItem(Start, uploadTask);
                        }
                    }
                }
            }
            finally
            {
                ContainerLocator.Current.Resolve<IEventAggregator>().GetEvent<IsIdleEvent>().Publish((this, true));
            }
        }

        /// <summary>
        /// 开始新的上传任务
        /// </summary>
        /// <param name="state"></param>
        private void Start(object state)
        {
            var uploadTask = (UploadTask)state;
            UploadClientBase uploadClient = null;

            try
            {
                if (uploadTask.UploadStatus == UploadStatus.Completed)
                {
                    // 跳过，不触发事件
                    lock (locker)
                    {
                        _uploading.Remove(uploadTask);

                        if (_uploading.Count < _maximumCount)
                            TryRelease(_maximumCount - _uploading.Count);
                    }
                    return;
                }

                var groupStatus = uploadTask.Group == null ? UploadStatus.Waiting : uploadTask.Group.UploadStatus;
                uploadTask.UploadStatus = UploadStatus.Uploading;
                uploadTask.BeginTime = DateTime.Now;

                Log.Info($"开始上传，URL：{uploadTask.Url}");

                if (uploadTask.PreviewUpload != null)
                {
                    var ret = uploadTask.PreviewUpload.Invoke(uploadTask);

                    if (!ret.IsSucc)
                        throw ret.Error ?? new Exception();

                    if (uploadTask.UploadStatus == UploadStatus.Completed)
                    {
                        uploadTask.UploadDataCompleted?.Invoke(uploadTask);

                        lock (locker)
                        {
                            _uploading.Remove(uploadTask);

                            if (_uploading.Count < _maximumCount)
                                TryRelease(_maximumCount - _uploading.Count);
                        }

                        return;
                    }
                }

                // 判断是否上传任务组
                if (uploadTask.Group != null && uploadTask.Group.PreviewUpload != null)
                {
                    var ret = uploadTask.Group.PreviewUpload.Invoke(uploadTask.Group);

                    if (!ret.IsSucc)
                        throw ret.Error ?? new Exception();
                    if (uploadTask.Group.UploadStatus == UploadStatus.Completed)
                    {
                        uploadTask.Group.UploadDataCompleted?.Invoke(uploadTask.Group);

                        lock (locker)
                        {
                            Remove(uploadTask.Group);

                            if (_uploading.Count < _maximumCount)
                                TryRelease(_maximumCount - _uploading.Count);
                        }

                        return;
                    }
                }

                lock (locker)
                {
                    if (!_uploading.ContainsKey(uploadTask))
                    {
                        throw new TaskCanceledException();
                    }

                    uploadClient = uploadTask.CreateUploadClient?.Invoke() ?? new HttpUploadClient(uploadTask);
                    uploadClient.UploadProgressChanged -= OnUploadProgressChanged;
                    uploadClient.UploadProgressChanged += OnUploadProgressChanged;
                    uploadClient.UploadDataCompleted -= OnUploadDataCompleted;
                    uploadClient.UploadDataCompleted += OnUploadDataCompleted;

                    _uploading[uploadTask] = uploadClient;
                }

                uploadTask.UploadStatus = UploadStatus.Uploading;
                uploadClient.BeginUpload();
            }
            catch (Exception ex)
            {
                Log.Info($"上传文件失败\tUrl：{uploadTask.Url}\tMsg：{ex.Message}");

                if (ex is TaskCanceledException)
                {
                    uploadTask.UploadStatus = UploadStatus.Cancelled;
                }
                else
                {
                    var msg = ErrorTexts.HttpError(ex, "上传文件");
                    uploadTask.ErrorMsg = msg;
                    Log.Error(uploadTask.Error = ex, msg);
                    uploadTask.UploadStatus = UploadStatus.Error;
                }

                uploadTask.UploadDataCompleted?.Invoke(uploadTask);

                lock (locker)
                {
                    if (uploadTask.Group != null)
                    {
                        uploadTask.Group.UploadDataCompleted?.Invoke(uploadTask.Group);
                        Remove(uploadTask.Group);
                    }
                    else
                        _uploading.Remove(uploadTask);

                    if (_uploading.Count < _maximumCount)
                        TryRelease(_maximumCount - _uploading.Count);
                }

                uploadClient?.Dispose();
            }
        }

        /// <summary>
        /// 上传进度改变或上传完成
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnUploadProgressChanged((UploadClientBase sender, long BytesSent, long TotalBytesToSend, int ProgressPercentage) e)
        {
            var uploadClient = e.sender;
            var uploadTask = uploadClient.UploadTask;

            uploadTask.ProgressPercentage = e.ProgressPercentage;
            uploadTask.TotalBytesToSend = e.TotalBytesToSend;
            uploadTask.BytesSent = e.BytesSent;

            if (uploadTask.UploadStatus == UploadStatus.Waiting)
                uploadTask.UploadStatus = UploadStatus.Uploading;

            uploadTask.UploadProgressChanged?.Invoke(uploadTask);
            uploadTask.Group?.UploadProgressChanged?.Invoke(uploadTask.Group);
        }

        /// <summary>
        /// 上传完成或上传失败或上传取消
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnUploadDataCompleted((UploadClientBase sender, Exception Error, bool Cancelled) e)
        {
            var uploadClient = e.sender;
            var uploadTask = uploadClient.UploadTask;

            uploadClient.UploadProgressChanged -= OnUploadProgressChanged;
            uploadClient.UploadDataCompleted -= OnUploadDataCompleted;

            var groupStatus = uploadTask.Group?.UploadStatus;

            try
            {
                uploadTask.EndTime = DateTime.Now;

                if (e.Cancelled)
                {
                    uploadTask.UploadStatus = UploadStatus.Cancelled;

                    // 取消整组
                    if (uploadTask.Group != null)
                    {
                        Remove(uploadTask.Group);
                        uploadTask.Group.UploadDataCompleted?.Invoke(uploadTask.Group);
                    }
                }
                else if (e.Error != null)
                {
                    var msg = ErrorTexts.HttpError(e.Error, "上传文件");
                    uploadTask.ErrorMsg = msg;
                    uploadTask.Error = e.Error;
                    uploadTask.UploadStatus = UploadStatus.Error;

                    // 取消整组
                    if (uploadTask.Group != null)
                    {
                        Remove(uploadTask.Group);
                        uploadTask.Group.UploadDataCompleted?.Invoke(uploadTask.Group);
                    }
                }
                else if (uploadTask.UploadStatus != UploadStatus.Completed)
                {
                    if (uploadTask.TotalBytesToSend == 0 || uploadTask.TotalBytesToSend != uploadTask.BytesSent)
                    {
                        var msg = uploadTask.TotalBytesToSend == 0 ? ErrorTexts.Get(ErrorTextType.ConnectFailed, "下载") : ErrorTexts.Get(ErrorTextType.NetworkDisconnect);
                        uploadTask.ErrorMsg = msg;
                        uploadTask.Error = new Exception(msg);
                        uploadTask.UploadStatus = UploadStatus.Error;

                        // 取消整组
                        if (uploadTask.Group != null)
                        {
                            Remove(uploadTask.Group);
                            uploadTask.Group.UploadDataCompleted?.Invoke(uploadTask.Group);
                        }
                    }
                    else
                    {
                        uploadTask.UploadStatus = UploadStatus.Completed;
                    }
                }

                uploadTask.UploadDataCompleted?.Invoke(uploadTask);

                if (uploadTask.Group != null && uploadTask.Group.UploadDataCompleted != null && uploadTask.Group.UploadStatus == UploadStatus.Completed)
                    uploadTask.Group.UploadDataCompleted.Invoke(uploadTask.Group);

                uploadTask.CompletedFlag = uploadTask.UploadStatus == UploadStatus.Completed;

                lock (locker)
                {
                    _uploading.Remove(uploadTask);

                    if (_uploading.Count < _maximumCount)
                        TryRelease(_maximumCount - _uploading.Count);
                }
            }
            catch (Exception ex)
            {
                try
                {
                    var msg = ErrorTexts.HttpError(ex, "上传文件");
                    uploadTask.ErrorMsg = msg;
                    uploadTask.Error = ex;
                    uploadTask.UploadStatus = UploadStatus.Error;
                    uploadTask.UploadDataCompleted?.Invoke(uploadTask);

                    if (uploadTask.Group != null && uploadTask.Group.UploadDataCompleted != null)
                        uploadTask.Group.UploadDataCompleted.Invoke(uploadTask.Group);

                    lock (locker)
                    {
                        _uploading.Remove(uploadTask);

                        if (_uploading.Count < _maximumCount)
                            TryRelease(_maximumCount - _uploading.Count);

                        if (uploadTask.Group != null)
                        {
                            uploadTask.Group.UploadDataCompleted?.Invoke(uploadTask.Group);
                            Remove(uploadTask.Group);
                        }
                    }
                }
                catch { }
            }
            finally
            {
                uploadClient.Dispose();

                if (uploadTask.Error != null)
                    Log.Error(uploadTask.Error, $"上传文件失败，{uploadTask.ErrorMsg}，Url：{uploadTask.Url}");
            }
        }

        private void TryRelease(int count = 1)
        {
            if (_semaphore == null)
                return;

            try
            {
                while (count-- > 0)
                {
                    _semaphore.Release();
                }
            }
            catch { }
        }

        public void GetCount(out int waitingCount, out int uploadingCount)
        {
            lock (locker)
            {
                waitingCount = _waiting.Count;
                uploadingCount = _uploading.Count;
            }
        }

        #endregion

        #region Property

        /// <summary>
        /// 上传器名称
        /// </summary>
        public string Name { get; }

        #endregion

        #region Field

        private object locker = new object();
        /// <summary>
        /// 信号量，限制同时上传数
        /// </summary>
        private Semaphore _semaphore;
        private int _maximumCount;
        /// <summary>
        /// 等待上传队列
        /// </summary>
        private List<UploadTask> _waiting = new List<UploadTask>();
        /// <summary>
        /// 正在上传队列
        /// </summary>
        private Dictionary<UploadTask, UploadClientBase> _uploading = new Dictionary<UploadTask, UploadClientBase>();
        private Thread _thread;

        #endregion
    }

    /// <summary>
    /// 上传任务
    /// </summary>
    public sealed class UploadTask : BindableBase, IRetry
    {
        private SpeedCalculator _speedCalculator;

        /// <summary>
        /// 上传任务
        /// </summary>
        /// <param name="uploadSpeedEnable">是否计算上传速度</param>
        public UploadTask(bool uploadSpeedEnable = false)
        {
            if (uploadSpeedEnable)
            {
                UploadProgressChanged += OnUploadProgressChangedForUploadSpeed;
                UploadDataCompleted += OnUploadDataCompletedForUploadSpeed;
            }
        }

        /// <summary>
        /// 上传名称
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 上传编码
        /// </summary>
        public string Code { get; set; }
        /// <summary>
        /// 额外信息
        /// </summary>
        public object Extra { get; set; }
        /// <summary>
        /// 额外信息2
        /// </summary>
        public object Extra2 { get; set; }
        /// <summary>
        /// 额外信息
        /// </summary>
        public Dictionary<String, String> Extras { get; set; }
        /// <summary>
        /// 上传链接
        /// </summary>
        public string Url { get; set; }
        /// <summary>
        /// 远程主机
        /// </summary>
        public string Host { get; set; }
        /// <summary>
        /// 端口号
        /// </summary>
        public int Port { get; set; }
        /// <summary>
        /// 用户名
        /// </summary>
        public string UserName { get; set; }
        /// <summary>
        /// 密码
        /// </summary>
        public string Password { get; set; }
        /// <summary>
        /// 文件流
        /// </summary>
        public Stream Stream { get; set; }
        /// <summary>
        /// 要上传的文件
        /// </summary>
        public string FilePath { get; set; }
        /// <summary>
        /// 请求头
        /// </summary>
        public Dictionary<String, String> Headers { get; set; }

        /// <summary>
        /// 上传进度改变或上传完成
        /// </summary>
        public Action<UploadTask> UploadProgressChanged { get; set; }
        /// <summary>
        /// 不触发事件的取消下载
        /// </summary>
        public Action<UploadTask> Removed { get; set; }

        /// <summary>
        /// 进度百分比
        /// </summary>
        public int ProgressPercentage { get; set; }
        /// <summary>
        /// 总字节数
        /// </summary>
        public long TotalBytesToSend { get; set; }
        /// <summary>
        /// 已发送字节数
        /// </summary>
        public long BytesSent { get; set; }
        /// <summary>
        /// 上传速度 B/s
        /// </summary>
        public long? UploadSpeed { get; private set; }
        /// <summary>
        /// 不显示下载速度
        /// </summary>
        public bool NoSpeed { get; set; }
        /// <summary>
        /// 固定百分比
        /// </summary>
        public double FixedPercentage { get; set; }
        /// <summary>
        /// 剩余时间（秒）
        /// </summary>
        public Double TimeRemaining { get; set; }
        /// <summary>
        /// 是否分包上传
        /// </summary>
        public bool IsPackage { get; set; }
        /// <summary>
        /// 分包字节偏移量
        /// </summary>
        public long PackageOffset { get; set; }
        /// <summary>
        /// 分包大小
        /// </summary>
        public long PackageSize { get; set; }
        /// <summary>
        /// 分包序号（从1开始）
        /// </summary>
        public int PackageIndex { get; set; }
        /// <summary>
        /// 分包总数
        /// </summary>
        public int PackageCount { get; set; }

        /// <summary>
        /// 上传完成或上传失败或上传取消
        /// </summary>
        public Action<UploadTask> UploadDataCompleted { get; set; }

        /// <summary>
        /// 是否已取消
        /// </summary>
        public bool Cancelled { get; set; }
        /// <summary>
        /// 发生的异常
        /// </summary>
        public Exception Error { get; set; }
        /// <summary>
        /// 错误消息
        /// </summary>
        public string ErrorMsg { get; set; }

        public string Response { get; set; }

        /// <summary>
        /// 上传状态
        /// </summary>
        public UploadStatus UploadStatus { get; set; }

        /// <summary>
        /// 所在上传任务组
        /// </summary>
        public UploadTaskGroup Group { get; set; }

        /// <summary>
        /// 所在上传器
        /// </summary>
        public UploadEngine UploadEngine { get; set; }

        /// <summary>
        /// 上传前触发
        /// </summary>
        public Func<UploadTask, ResultValue> PreviewUpload { get; set; }
        /// <summary>
        /// 上传中触发
        /// </summary>
        public Func<UploadTask, ResultValue> Uploading { get; set; }

        /// <summary>
        /// 自定义上传方式
        /// </summary>
        public Func<UploadClientBase> CreateUploadClient { get; set; }

        public Action<object> Retrying { get; set; }

        /// <summary>
        /// 开始时间
        /// </summary>
        public DateTime? BeginTime { get; set; }
        /// <summary>
        /// 结束时间
        /// </summary>
        public DateTime? EndTime { get; set; }
        /// <summary>
        /// 上传耗时
        /// </summary>
        public TimeSpan? Duration => EndTime - BeginTime;
        /// <summary>
        /// 平均上传速度
        /// </summary>
        public long? AverageUploadSpeed => EndTime.HasValue ? ((long?)(BytesSent / Duration?.TotalSeconds)) : null;

        /// <summary>
        /// 上传完成标识
        /// </summary>
        public bool CompletedFlag { get; set; }

        private void OnUploadProgressChangedForUploadSpeed(UploadTask obj)
        {
            if (UploadStatus == UploadStatus.Uploading && _speedCalculator == null && !NoSpeed)
            {
                _speedCalculator = new SpeedCalculator(() => BytesSent, n =>
                {
                    if (UploadStatus != UploadStatus.Uploading)
                    {
                        if (_speedCalculator != null)
                        {
                            _speedCalculator.Dispose();
                            _speedCalculator = null;
                        }
                    }

                    UploadSpeed = n;
                    if (n == 0)
                    {
                        TimeRemaining = Double.NaN;
                    }
                    else
                    {
                        var bytes_remaining = TotalBytesToSend - BytesSent;
                        TimeRemaining = bytes_remaining / n;
                    }
                    UploadProgressChanged?.Invoke(this);
                });
                _speedCalculator.Start(BytesSent);
            }

            RaisePropertyChanged(null);
        }

        private void OnUploadDataCompletedForUploadSpeed(UploadTask obj)
        {
            if (_speedCalculator != null)
            {
                _speedCalculator.Dispose();
                _speedCalculator = null;
            }

            RaisePropertyChanged(null);
        }

        public void Retry()
        {
            UploadStatus = UploadStatus.Waiting;
            BytesSent = 0;
            TotalBytesToSend = 0;
            ProgressPercentage = 0;
            Error = null;
            ErrorMsg = null;
            Cancelled = false;

            Retrying?.Invoke(this);
            RaisePropertyChanged(null);
            UploadEngine.Add(this);
        }

        public override string ToString()
        {
            var sb = new StringBuilder(nameof(UploadTask));

            if (!String.IsNullOrEmpty(Name))
            {
                sb.Append(", name: " + Name);
            }
            if (!String.IsNullOrEmpty(Url))
            {
                sb.Append(", url: " + Url);
            }
            if (!String.IsNullOrEmpty(Host))
            {
                sb.Append(", host: " + Host);
            }
            if (Port != 0)
            {
                sb.Append(", port: " + Port);
            }
            if (!String.IsNullOrEmpty(UserName))
            {
                sb.Append(", userName: " + UserName);
            }
            if (!String.IsNullOrEmpty(Password))
            {
                sb.Append(", password: " + Password);
            }
            if (!String.IsNullOrEmpty(FilePath))
            {
                sb.Append(", filePath: " + FilePath);
            }
            sb.Append($", uploadStatus: {UploadStatus}。");

            return sb.ToString();
        }
    }

    /// <summary>
    /// 上传任务组
    /// </summary>
    public sealed class UploadTaskGroup : BindableBase, IRetry
    {
        private SpeedCalculator _speedCalculator;

        /// <summary>
        /// 上传任务组
        /// </summary>
        /// <param name="uploadTasks">子上传任务</param>
        public UploadTaskGroup(IEnumerable<UploadTask> uploadTasks, bool uploadSpeedEnable = false)
        {
            Children = new List<UploadTask>(uploadTasks);

            foreach (var uploadTask in uploadTasks)
            {
                uploadTask.Group = this;
            }

            if (uploadSpeedEnable)
            {
                UploadProgressChanged += OnUploadProgressChangedForUploadSpeed;
                UploadDataCompleted += OnUploadDataCompletedForUploadSpeed;
            }
        }

        /// <summary>
        /// 子上传任务
        /// </summary>
        public List<UploadTask> Children { get; }
        /// <summary>
        /// 追加子任务
        /// </summary>
        public Action<UploadTask> Appended { get; set; }

        /// <summary>
        /// 上传名称
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 上传编码
        /// </summary>
        public string Code { get; set; }
        /// <summary>
        /// 额外信息
        /// </summary>
        public object Extra { get; set; }

        /// <summary>
        /// 上传进度改变或上传完成
        /// </summary>
        public Action<UploadTaskGroup> UploadProgressChanged { get; set; }

        /// <summary>
        /// 进度百分比
        /// </summary>
        public int ProgressPercentage
        {
            get
            {
                var fixedSum = Children.Sum(q => q.FixedPercentage) / 100;
                var totalBytes = (long)(TotalBytesToSend / (1 - fixedSum));

                var sent = 0d;
                foreach (var child in Children)
                {
                    if (child.FixedPercentage == 0)
                    {
                        sent += child.BytesSent;
                    }
                    else
                    {
                        switch (child.UploadStatus)
                        {
                            case UploadStatus.Completed:
                                sent += totalBytes * child.FixedPercentage / 100;
                                break;
                            case UploadStatus.Uploading:
                                sent += totalBytes * child.FixedPercentage / 100 * child.ProgressPercentage / 100;
                                break;
                        }
                    }
                }

                return totalBytes == 0 ? 0 : (int)(sent * 100 / totalBytes);
            }
        }
        /// <summary>
        /// 总字节数
        /// </summary>
        public long TotalBytesToSend => Children.Where(q => q.FixedPercentage == 0).Sum(q => q.TotalBytesToSend);
        /// <summary>
        /// 已上传字节数
        /// </summary>
        public long BytesSent => Children.Where(q => q.FixedPercentage == 0).Sum(q => q.BytesSent);
        /// <summary>
        /// 上传速度 B/s
        /// </summary>
        public long? UploadSpeed { get; private set; }
        /// <summary>
        /// 不显示下载速度
        /// </summary>
        public bool NoSpeed => CurrentUploadTask.NoSpeed;
        /// <summary>
        /// 剩余时间（秒）
        /// </summary>
        public Double TimeRemaining { get; set; }

        /// <summary>
        /// 上传完成或上传失败或上传取消
        /// </summary>
        public Action<UploadTaskGroup> UploadDataCompleted { get; set; }

        /// <summary>
        /// 发生的异常
        /// </summary>
        public Exception Error => Children.FirstOrDefault(q => q.Error != null)?.Error;
        /// <summary>
        /// 错误消息
        /// </summary>
        public string ErrorMsg => Children.FirstOrDefault(q => q.Error != null)?.ErrorMsg;

        /// <summary>
        /// 上传状态
        /// </summary>
        public UploadStatus UploadStatus
        {
            get
            {
                if (Children.Any(q => q.UploadStatus == UploadStatus.Error))
                    return UploadStatus.Error;
                if (Children.Any(q => q.UploadStatus == UploadStatus.Cancelled))
                    return UploadStatus.Cancelled;
                if (Children.Any(q => q.UploadStatus == UploadStatus.Uploading))
                    return UploadStatus.Uploading;
                if (Children.All(q => q.UploadStatus == UploadStatus.Waiting))
                    return UploadStatus.Waiting;
                if (Children.Any(q => q.UploadStatus == UploadStatus.Waiting))
                    return UploadStatus.Uploading;
                return UploadStatus.Completed;
            }
        }

        public UploadTask CurrentUploadTask
        {
            get
            {
                while (Children.Count > 0)
                {
                    var uploadTask = GetUploadTask();
                    if (uploadTask != null)
                    {
                        return uploadTask;
                    }
                    Thread.Yield();
                }
                return null;
            }
        }
        private UploadTask GetUploadTask()
        {
            var status = UploadStatus;

            if (status == UploadStatus.Waiting)
                return Children.FirstOrDefault(q => q.UploadStatus == status);
            else if (status == UploadStatus.Uploading)
                return Children.FirstOrDefault(q => q.UploadStatus == status) ?? Children.FirstOrDefault(q => q.UploadStatus == UploadStatus.Waiting);
            else
                return Children.LastOrDefault(q => q.UploadStatus == status) ?? Children.LastOrDefault();
        }

        /// <summary>
        /// 所在上传器
        /// </summary>
        public UploadEngine UploadEngine { get; set; }

        /// <summary>
        /// 上传前触发
        /// </summary>
        public Func<UploadTaskGroup, ResultValue> PreviewUpload { get; set; }
        public Action<object> Retrying { get; set; }

        /// <summary>
        /// 开始时间
        /// </summary>
        public DateTime? BeginTime => Children.Where(q => q.BeginTime.HasValue).Min(q => q.BeginTime);
        /// <summary>
        /// 结束时间
        /// </summary>
        public DateTime? EndTime => Children.Where(q => q.EndTime.HasValue || q.BeginTime.HasValue).Max(q => q.EndTime.HasValue ? q.EndTime : q.BeginTime);
        /// <summary>
        /// 上传耗时
        /// </summary>
        public TimeSpan? Duration => EndTime - BeginTime;
        /// <summary>
        /// 平均上传速度
        /// </summary>
        public long? AverageUploadSpeed => EndTime.HasValue ? ((long?)(BytesSent / Duration?.TotalSeconds)) : null;

        private void OnUploadProgressChangedForUploadSpeed(UploadTaskGroup obj)
        {
            if (UploadStatus == UploadStatus.Uploading && _speedCalculator == null)
            {
                _speedCalculator = new SpeedCalculator(() => BytesSent, n =>
                {
                    if (UploadStatus != UploadStatus.Uploading)
                    {
                        if (_speedCalculator != null)
                        {
                            _speedCalculator.Dispose();
                            _speedCalculator = null;
                        }
                    }
                    if (NoSpeed)
                    {
                        UploadSpeed = null;
                        TimeRemaining = Double.NaN;
                    }
                    else
                    {
                        UploadSpeed = n;
                        if (n == 0)
                        {
                            TimeRemaining = Double.NaN;
                        }
                        else
                        {
                            var bytes_remaining = TotalBytesToSend - BytesSent;
                            TimeRemaining = bytes_remaining / n;
                        }
                    }

                    UploadProgressChanged?.Invoke(this);
                });
                _speedCalculator.Start(BytesSent);
            }

            RaisePropertyChanged(null);
        }

        private void OnUploadDataCompletedForUploadSpeed(UploadTaskGroup obj)
        {
            if (_speedCalculator != null)
            {
                _speedCalculator.Dispose();
                _speedCalculator = null;
            }

            RaisePropertyChanged(null);
        }

        public void Retry()
        {
            foreach (var child in Children)
            {
                child.UploadStatus = UploadStatus.Waiting;
                child.BytesSent = 0;
                child.TotalBytesToSend = 0;
                child.ProgressPercentage = 0;
                child.Error = null;
                child.ErrorMsg = null;
                child.Cancelled = false;

                child.Retrying?.Invoke(child);
                child.RaisePropertyChanged(null);
            }

            Retrying?.Invoke(this);
            RaisePropertyChanged(null);
            UploadEngine.Add(this);
        }

        public override string ToString()
        {
            var sb = new StringBuilder(nameof(UploadTaskGroup));

            if (!String.IsNullOrEmpty(Name))
            {
                sb.Append(", name: " + Name);
            }
            sb.Append($", uploadStatus: {UploadStatus}。");

            return sb.ToString();
        }
    }

    /// <summary>
    /// 上传进度监测器
    /// </summary>
    public sealed class UploadProgressWatcher : BindableBase, IDisposable
    {
        private SpeedCalculator _speedCalculator;
        private readonly List<UploadTask> _uploadTasks = new List<UploadTask>();

        public UploadProgressWatcher()
        {
            UploadProgressChanged += OnUploadProgressChangedForUploadSpeed;
            UploadDataCompleted += OnUploadFileCompletedForUploadSpeed;
        }

        public void AppendUploadTask(UploadTask uploadTask)
        {
            if (_uploadTasks.Contains(uploadTask))
            {
                return;
            }

            _uploadTasks.Add(uploadTask);

            if (uploadTask.TotalBytesToSend == 0 && uploadTask != CurrentUploadTask && uploadTask.PreviewUpload != null)
            {
                var ret = uploadTask.PreviewUpload.Invoke(uploadTask);

                if (!ret.IsSucc)
                {
                    _uploadTasks.Remove(uploadTask);
                    return;
                }
            }

            UploadProgressChanged?.Invoke(this);

            uploadTask.UploadProgressChanged -= OnUploadTaskUploadProgressChanged;
            uploadTask.UploadProgressChanged += OnUploadTaskUploadProgressChanged;
            uploadTask.UploadDataCompleted -= OnUploadTaskUploadDataCompleted;
            uploadTask.UploadDataCompleted += OnUploadTaskUploadDataCompleted;
            uploadTask.Removed -= OnUploadTaskRemoved;
            uploadTask.Removed += OnUploadTaskRemoved;
        }

        public void AppendUploadTaskGroup(UploadTaskGroup group)
        {
            foreach (var uploadTask in group.Children)
            {
                AppendUploadTask(uploadTask);
            }

            group.Appended -= AppendUploadTask;
            group.Appended += AppendUploadTask;
            group.UploadDataCompleted -= OnUploadTaskGroupUploadDataCompleted;
            group.UploadDataCompleted += OnUploadTaskGroupUploadDataCompleted;
        }


        public UploadTask[] UploadTasks => _uploadTasks.ToArray();
        /// <summary>
        /// 上传进度改变或上传完成
        /// </summary>
        public Action<UploadProgressWatcher> UploadProgressChanged { get; set; }

        /// <summary>
        /// 进度百分比
        /// </summary>
        public int ProgressPercentage
        {
            get
            {
                var fixedSum = _uploadTasks.Sum(q => q.FixedPercentage) / 100 / _uploadTasks.Count;
                var totalBytes = (long)(TotalBytesToSend / (1 - fixedSum));

                var sent = 0d;

                foreach (var child in _uploadTasks)
                {
                    if (child.FixedPercentage == 0)
                    {
                        sent += child.BytesSent;
                    }
                    else
                    {
                        switch (child.UploadStatus)
                        {
                            case UploadStatus.Completed:
                                sent += totalBytes * child.FixedPercentage / 100 / _uploadTasks.Count;
                                break;
                            case UploadStatus.Uploading:
                                sent += totalBytes * child.FixedPercentage / 100 / _uploadTasks.Count * child.ProgressPercentage / 100;
                                break;
                        }
                    }
                }

                return totalBytes == 0 ? 0 : (int)(sent * 100 / totalBytes);
            }
        }
        /// <summary>
        /// 总字节数
        /// </summary>
        public long TotalBytesToSend => _uploadTasks.Where(q => q.FixedPercentage == 0).Sum(q => q.TotalBytesToSend);
        /// <summary>
        /// 已上传字节数
        /// </summary>
        public long BytesSent => _uploadTasks.Where(q => q.FixedPercentage == 0).Sum(q => q.BytesSent);
        /// <summary>
        /// 上传速度 B/s
        /// </summary>
        public long? UploadSpeed { get; private set; }

        /// <summary>
        /// 上传完成或上传失败或上传取消
        /// </summary>
        public Action<UploadProgressWatcher> UploadDataCompleted { get; set; }

        /// <summary>
        /// 上传状态
        /// </summary>
        public UploadStatus UploadStatus
        {
            get
            {
                var tasks = _uploadTasks.Where(q => q.UploadStatus != UploadStatus.Cancelled && q.UploadStatus != UploadStatus.Error).ToArray();

                if (tasks.Any(q => q.UploadStatus == UploadStatus.Uploading))
                    return UploadStatus.Uploading;
                if (tasks.All(q => q.UploadStatus == UploadStatus.Waiting))
                    return UploadStatus.Waiting;
                else
                    return UploadStatus.Completed;
            }
        }

        public UploadTask CurrentUploadTask
        {
            get
            {
                while (_uploadTasks.Count > 0)
                {
                    var uploadTask = GetUploadTask();
                    if (uploadTask != null)
                    {
                        return uploadTask;
                    }
                    Thread.Yield();
                }
                return null;
            }
        }
        private UploadTask GetUploadTask()
        {
            var status = UploadStatus;

            if (status == UploadStatus.Waiting)
                return _uploadTasks.FirstOrDefault(q => q.UploadStatus == status);
            else if (status == UploadStatus.Uploading)
                return _uploadTasks.FirstOrDefault(q => q.UploadStatus == status) ?? _uploadTasks.FirstOrDefault(q => q.UploadStatus == UploadStatus.Waiting);
            else
                return _uploadTasks.LastOrDefault(q => q.UploadStatus == status) ?? _uploadTasks.LastOrDefault();
        }

        private void OnUploadTaskUploadProgressChanged(UploadTask uploadTask)
        {
            UploadProgressChanged?.Invoke(this);
        }

        private void OnUploadTaskUploadDataCompleted(UploadTask uploadTask)
        {
            uploadTask.UploadDataCompleted -= OnUploadTaskUploadDataCompleted;

            if (_uploadTasks.All(q => q.UploadStatus == UploadStatus.Completed || q.UploadStatus == UploadStatus.Cancelled || q.UploadStatus == UploadStatus.Error))
            {
                UploadDataCompleted?.Invoke(this);
            }
        }

        private void OnUploadTaskRemoved(UploadTask uploadTask)
        {
            uploadTask.Removed -= OnUploadTaskRemoved;
            _uploadTasks.Remove(uploadTask);

            UploadProgressChanged?.Invoke(this);
        }

        private void OnUploadTaskGroupUploadDataCompleted(UploadTaskGroup group)
        {
            group.UploadDataCompleted -= OnUploadTaskGroupUploadDataCompleted;
            group.Appended -= AppendUploadTask;
        }

        private void OnUploadProgressChangedForUploadSpeed(UploadProgressWatcher watcher)
        {
            if (UploadStatus == UploadStatus.Uploading && _speedCalculator == null && BytesSent > 0)
            {
                _speedCalculator = new SpeedCalculator(() => BytesSent, n =>
                {
                    if (UploadStatus != UploadStatus.Uploading)
                    {
                        if (_speedCalculator != null)
                        {
                            _speedCalculator.Dispose();
                            _speedCalculator = null;
                        }
                    }

                    UploadSpeed = n;
                    UploadProgressChanged?.Invoke(this);
                });
                _speedCalculator.Start(BytesSent);
            }

            RaisePropertyChanged(null);
        }

        private void OnUploadFileCompletedForUploadSpeed(UploadProgressWatcher watcher)
        {
            if (_speedCalculator != null)
            {
                _speedCalculator.Dispose();
                _speedCalculator = null;
            }

            RaisePropertyChanged(null);
        }

        public void Dispose()
        {
            if (_speedCalculator != null)
            {
                _speedCalculator.Dispose();
                _speedCalculator = null;
            }

            foreach (var uploadTask in _uploadTasks)
            {
                uploadTask.UploadProgressChanged -= OnUploadTaskUploadProgressChanged;
                uploadTask.UploadDataCompleted -= OnUploadTaskUploadDataCompleted;
                uploadTask.Removed -= OnUploadTaskRemoved;

                var group = uploadTask.Group;

                if (group != null)
                {
                    group.Appended -= AppendUploadTask;
                    group.UploadDataCompleted -= OnUploadTaskGroupUploadDataCompleted;
                }
            }
        }
    }

    public abstract class UploadClientBase : IDisposable
    {
        public UploadClientBase(UploadTask uploadTask)
        {
            _uploadTask = uploadTask;
        }

        public abstract void BeginUpload();

        public abstract void BeginCancel();

        public abstract void Dispose();

        #region Property

        public UploadTask UploadTask => _uploadTask;

        public Action<(UploadClientBase sender, long BytesSent, long TotalBytesToSend, int ProgressPercentage)> UploadProgressChanged { get; set; }
        public Action<(UploadClientBase sender, Exception Error, bool Cancelled)> UploadDataCompleted { get; set; }

        #endregion

        #region Field

        private UploadTask _uploadTask;

        #endregion
    }

    public class HttpUploadClient : UploadClientBase
    {
        public HttpUploadClient(UploadTask uploadTask) : base(uploadTask)
        {
            _request = (HttpWebRequest)WebRequest.Create(uploadTask.Url);

            _request.Method = "POST";
            _request.UseDefaultCredentials = true;
            _request.Timeout = 60_000 * 60;
            _request.KeepAlive = true;
        }

        public override void BeginUpload()
        {
            _cts.TryCancel();
            _cts = new CancellationTokenSource();

            ThreadPool.QueueUserWorkItem(n =>
            {
                var token = (CancellationToken)n;

                try
                {
                    if (UploadTask.Uploading != null)
                    {
                        var ret = UploadTask.Uploading.Invoke(UploadTask);

                        if (token.IsCancellationRequested)
                        {
                            UploadDataCompleted?.Invoke((this, null, token.IsCancellationRequested));
                            return;
                        }

                        if (!ret.IsSucc)
                        {
                            UploadDataCompleted?.Invoke((this, ret.Error, token.IsCancellationRequested));
                        }
                    }

                    var uri = new Uri(UploadTask.Url, UriKind.RelativeOrAbsolute);

                    if ((UploadTask.Stream == null || !UploadTask.Stream.CanRead) && File.Exists(UploadTask.FilePath))
                        UploadTask.Stream = File.OpenRead(UploadTask.FilePath);

                    if (UploadTask.Headers != null)
                    {
                        foreach (var kv in UploadTask.Headers)
                        {
                            if ("Content-Type".Equals(kv.Key, StringComparison.OrdinalIgnoreCase))
                            {
                                _request.ContentType = kv.Value;
                                continue;
                            }

                            _request.Headers.Set(kv.Key, kv.Value);
                        }
                    }
                    _request.ContentLength = UploadTask.Stream.Length;

                    using (var stream = UploadTask.Stream)
                    {
                        using (var reqStream = _request.GetRequestStream())
                        {
                            if (stream.CanSeek)
                                stream.Seek(0, SeekOrigin.Begin);

                            var buffLength = 1024;
                            var buff = new byte[buffLength];

                            var contentLen = 0;
                            UploadTask.BytesSent = 0L;

                            do
                            {
                                contentLen = stream.Read(buff, 0, buffLength);
                                reqStream.Write(buff, 0, contentLen);

                                UploadTask.BytesSent += contentLen;

                                UploadProgressChanged?.Invoke((this, UploadTask.BytesSent, stream.Length, (int)(UploadTask.BytesSent * 100d / stream.Length)));
                            }
                            while (contentLen != 0 && !token.IsCancellationRequested);

                            reqStream.Flush();
                        }
                    }

                    if (!token.IsCancellationRequested)
                    {
                        using (var response = (HttpWebResponse)_request.GetResponse())
                        {
                            using (var sr = new StreamReader(response.GetResponseStream()))
                            {
                                UploadTask.Response = sr.ReadToEnd();
                                Log.Info($"上传成功，大小：{UploadTask.TotalBytesToSend}，上传地址：{UploadTask.Url}，{UploadTask.Response}");
                            }
                        }
                    }

                    UploadDataCompleted?.Invoke((this, null, token.IsCancellationRequested));
                }
                catch (Exception ex)
                {
                    UploadDataCompleted?.Invoke((this, ex, token.IsCancellationRequested));
                }
            }, _cts.Token);
        }

        public override void BeginCancel()
        {
            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        public override void Dispose()
        {
            _request.Abort();

            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        #region Field

        private HttpWebRequest _request;
        private CancellationTokenSource _cts;

        #endregion
    }

    public class FtpUploadClient : UploadClientBase
    {
        public FtpUploadClient(UploadTask uploadTask) : base(uploadTask)
        {
            _ftp = (FtpWebRequest)FtpWebRequest.Create(new Uri(uploadTask.Url, UriKind.RelativeOrAbsolute));
            _ftp.Credentials = new NetworkCredential(uploadTask.UserName, uploadTask.Password);
            _ftp.Method = WebRequestMethods.Ftp.UploadFile;
            _ftp.UseBinary = true;
        }

        public override void BeginUpload()
        {
            _cts?.TryCancel();
            _cts = new CancellationTokenSource();

            ThreadPool.QueueUserWorkItem(n =>
            {
                var token = (CancellationToken)n;

                try
                {
                    if ((UploadTask.Stream == null || !UploadTask.Stream.CanRead) && File.Exists(UploadTask.FilePath))
                        UploadTask.Stream = File.OpenRead(UploadTask.FilePath);

                    using (var stream = UploadTask.Stream)
                    {
                        using (var reqStream = _ftp.GetRequestStream())
                        {
                            if (stream.CanSeek)
                                stream.Seek(0, SeekOrigin.Begin);

                            var buffLength = 1024;
                            var buff = new byte[buffLength];

                            var contentLen = 0;
                            UploadTask.BytesSent = 0L;

                            do
                            {
                                contentLen = stream.Read(buff, 0, buffLength);
                                reqStream.Write(buff, 0, contentLen);

                                UploadTask.BytesSent += contentLen;

                                UploadProgressChanged?.Invoke((this, UploadTask.BytesSent, stream.Length, (int)(UploadTask.BytesSent * 100d / stream.Length)));
                            }
                            while (contentLen != 0 && !token.IsCancellationRequested);

                            reqStream.Flush();
                        }
                    }

                    UploadDataCompleted?.Invoke((this, null, token.IsCancellationRequested));
                }
                catch (Exception ex)
                {
                    UploadDataCompleted?.Invoke((this, ex, token.IsCancellationRequested));
                }
            }, _cts.Token);
        }

        public override void BeginCancel()
        {
            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        public override void Dispose()
        {
            _ftp.Abort();

            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        #region Field

        private FtpWebRequest _ftp;
        private CancellationTokenSource _cts;

        #endregion
    }

    public class SftpUploadClient : UploadClientBase
    {
        public SftpUploadClient(UploadTask uploadTask) : base(uploadTask)
        {
            _sftp = new SftpClient(uploadTask.Host, uploadTask.Port, uploadTask.UserName, uploadTask.Password);
        }

        public override void BeginUpload()
        {
            _cts?.TryCancel();
            _cts = new CancellationTokenSource();

            ThreadPool.QueueUserWorkItem(n =>
            {
                var token = (CancellationToken)n;

                try
                {
                    _sftp.Connect();

                    if ((UploadTask.Stream == null || !UploadTask.Stream.CanRead) && File.Exists(UploadTask.FilePath))
                        UploadTask.Stream = File.OpenRead(UploadTask.FilePath);

                    using (var stream = UploadTask.Stream)
                    {
                        if (stream.CanSeek)
                            stream.Seek(0, SeekOrigin.Begin);

                        _sftp.UploadFile(stream, UploadTask.Url, m => { UploadTask.BytesSent = (long)m; UploadProgressChanged?.Invoke((this, UploadTask.BytesSent, UploadTask.TotalBytesToSend, (int)(m * 100d / UploadTask.TotalBytesToSend))); });

                        if (UploadTask.BytesSent != UploadTask.TotalBytesToSend)
                        {
                            UploadTask.BytesSent = UploadTask.TotalBytesToSend;
                            UploadProgressChanged?.Invoke((this, UploadTask.BytesSent, UploadTask.TotalBytesToSend, 100));
                        }
                    }

                    UploadDataCompleted?.Invoke((this, null, token.IsCancellationRequested));
                }
                catch (Exception ex)
                {
                    UploadDataCompleted?.Invoke((this, ex, token.IsCancellationRequested));
                }
            }, _cts.Token);
        }

        public override void BeginCancel()
        {
            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        public override void Dispose()
        {
            _sftp.Dispose();

            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }
        }

        #region Field

        private SftpClient _sftp;
        private CancellationTokenSource _cts;

        #endregion
    }

    public class CustomUploadClient : UploadClientBase
    {
        public CustomUploadClient(UploadTask uploadTask) : base(uploadTask) { }

        public override void BeginUpload()
        {
            if (BeginUploadCalled == null)
            {
                UploadTask.UploadStatus = UploadStatus.Completed;
                UploadDataCompleted?.Invoke((this, null, false));
            }
            else
            {
                _cts?.TryCancel();
                _cts = new CancellationTokenSource();
                BeginUploadCalled.Invoke(this, _cts.Token);
            }
        }

        public override void BeginCancel()
        {
            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }

            if (BeginCancelCalled != null)
            {
                BeginCancelCalled.Invoke(this);
            }
            else
            {
                UploadDataCompleted?.Invoke((this, null, true));
            }
        }

        public override void Dispose()
        {
            if (_cts != null)
            {
                _cts.TryCancel();
                _cts = null;
            }

            DisposeCalled?.Invoke(this);
        }

        #region Property

        public Action<CustomUploadClient, CancellationToken> BeginUploadCalled { get; set; }

        public Action<CustomUploadClient> BeginCancelCalled { get; set; }

        public Action<CustomUploadClient> DisposeCalled { get; set; }

        #endregion

        #region Field

        private CancellationTokenSource _cts;

        #endregion
    }
}