WebApi分块下载文件

    事情是这样的，最近改了下载文件的接口，原来是直接返回文件在服务器的路径，感觉不怎么好，所以就改了一下改成直接返回文件流。但是别人嵌入式的同事调用以后发现改成流以后就不能分块下载文件了，这才了解到原来嵌入式设备下载大文件一般会采取分块的方式进行下载，这样的好处是一部分一部分的下载，如果断了也能断点续传。

---

    特意研究了一下，文件的断点续传原来http协议中本身就支持这个，在请求的header中设置range属性就可以实现断点续传了，实现代码如下：

        /// <summary>
        /// 分块下载文件
        /// 分块下载文件时需要在header中加一个range参数，格式为 Range:bytes=0-100/1234   起始位置-结束位置/总长度
        /// </summary>
        /// <returns></returns>
        public dynamic BlockDownload(string fileName)
        {
            string filePath = HttpRuntime.AppDomainAppPath + $"Files/{fileName}";
            if (File.Exists(filePath))
            {
                //设置FileShare 防止 同时访问造成占用
                using (FileStream fs = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    HttpResponseMessage response = new HttpResponseMessage();
                    int bufferSize = 1024 * 100;
                    byte[] bytes = new byte[bufferSize];
                    //判断是否分块下载
                    if (Request.Headers.Range == null ||
                        Request.Headers.Range.Ranges.Count == 0)
                    {
                        fs.Read(bytes, 0, bufferSize);
                        response.Headers.AcceptRanges.Add("bytes");
                        MemoryStream ms = new MemoryStream(bytes);
                        response.Content = new StreamContent(ms);
                        response.Content.Headers.ContentLength = fs.Length;
                    }
                    else
                    {
                        var range = Request.Headers.Range.Ranges.FirstOrDefault();
                        long endPosition = 0;
                        if (range != null && range.To.HasValue)
                        {
                            endPosition = range.To.Value;
                        }
                        else
                        {
                            endPosition = fs.Length;
                        }

                        //code 206
                        response.StatusCode = HttpStatusCode.PartialContent;
                        int size = Convert.ToInt32(endPosition - range.From.Value) + 1;
                        bytes = new byte[size];
                        fs.Position = range.From.Value;
                        fs.Read(bytes, 0, size);
                        MemoryStream ms = new MemoryStream(bytes);
                        response.Content = new StreamContent(ms);
                        response.Content.Headers.ContentRange = new ContentRangeHeaderValue(range.From.Value, endPosition, fs.Length);
                        response.Content.Headers.ContentLength = size;
                    }
                    return response;
                }
            }
            return null;
        }

    这样就可以实现文件分块下载了，也可以用多线程的方式下载文件，每个下称下载一小块，这样也能提高下载速度。

    下面再放一个下载的demo，是用线程下载的，代码如下：

/// <summary>
        /// 获得文件
        /// </summary>
        /// <param name="fileName"></param>
        [HttpGet]
        public async void GetFile(string fileName)
        {
            string url = $"http://localhost:57583/api/FileManage/BlockDownload?fileName={fileName}";
            string filePath = HttpRuntime.AppDomainAppPath + $"Files/";
            using (HttpClient client = new HttpClient())
            {
                var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
                long fileLength = response.Content.Headers.ContentLength.Value;
                long blockSize = (long)fileLength / 4;
                List<long> sizeList = new List<long>();
                var tasks = new List<Task>();
                //强行分了4块下载
                for (int i = 0; i < 3; i++)
                {
                    var begin = i * blockSize;
                    var end = begin + blockSize - 1;
                    tasks.Add(DownLoad(url, begin, end, i));
                }
                tasks.Add(DownLoad(url, 3 * blockSize, fileLength, 3));
                await Task.WhenAll(tasks);

                for (int i = 0; i < 4; i++)
                {
                    using (FileStream fs = new FileStream(filePath + DateTime.Now.ToString("yyyyMMddhhmmss") + fileName, FileMode.Append, FileAccess.Write))
                    {
                        byte[] bytes = File.ReadAllBytes(filePath + i);
                        fs.Write(bytes, 0, bytes.Length);
                    }
                    File.Delete(filePath + i);
                }
            }
        }

        /// <summary>
        /// 下载
        /// </summary>
        /// <param name="url"></param>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        private async Task DownLoad(string url, long start, long end, int index)
        {
            string filePath = HttpRuntime.AppDomainAppPath + $"Files/";
            using (HttpClient client = new HttpClient())
            {
                client.DefaultRequestHeaders.Range = new RangeHeaderValue(start, end);
                var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
                var stream = await response.Content.ReadAsStreamAsync();
                var bufferSize = 1024 * 100;
                int wirtesize;
                byte[] bytes = new byte[bufferSize];
                while ((wirtesize = stream.Read(bytes, 0, bufferSize)) > 0)
                {
                    using (FileStream fs = new FileStream(filePath + index, FileMode.Append, FileAccess.Write))
                    {
                        fs.Write(bytes, 0, (int)wirtesize);
                    }
                }
            }
        }

    ok，全部结束，如有问题欢迎批评指正。