API返回压缩、解压缩文件

    public class CompressHelper
    {
        /// <summary>
        /// 将多个已读到内存中的文件压缩到一个文件中
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="fileList"></param>
        public static void CompresstoZip(string fileName, Dictionary<string, byte[]> fileList)
        {
            using (var memoryStream = new MemoryStream())
            {
                using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))
                {
                    foreach (var file in fileList)
                    {
                        var demoFile = archive.CreateEntry(file.Key);

                        using (var entryStream = demoFile.Open())
                        using (var b = new BinaryWriter(entryStream))
                        {
                            b.Write(file.Value);
                        }
                    }
                }

                using (var fileStream = new FileStream(fileName, FileMode.Create))
                {
                    memoryStream.Seek(0, SeekOrigin.Begin);
                    memoryStream.CopyTo(fileStream);
                }
            }
        }
        /// <summary>
        /// 将多个已读到内存中的文件压缩到一个文件中并返回一个MemoryStream
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="fileList"></param>
        /// <returns></returns>
        public static MemoryStream CompresstoZipStreamUseZipArchive(string fileName, Dictionary<string, byte[]> fileList)
        {
            var memoryStream = new MemoryStream();

            using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))
            {
                foreach (var file in fileList)
                {
                    var demoFile = archive.CreateEntry(file.Key);

                    using (var entryStream = demoFile.Open())
                    using (var b = new BinaryWriter(entryStream))
                    {
                        b.Write(file.Value);
                    }
                }
            }

            using (var fileStream = new FileStream(fileName, FileMode.Create))
            {
                memoryStream.Seek(0, SeekOrigin.Begin);
                memoryStream.CopyTo(fileStream);
            }

            //把内存流指针恢复到起始位置
            memoryStream.Seek(0, SeekOrigin.Begin);
            return memoryStream;
        }

        /// <summary>
        /// 解压Zip文件，并覆盖保存到指定的目标路径文件夹下
        /// </summary>
        /// <param name="zipFilePath">将要解压缩的zip文件的路径</param>
        /// <param name="unZipDir">解压后将zip中的文件存储到磁盘的目标路径</param>
        /// <returns></returns>
        public static void DecompressUseZipArchive(string zipFilePath, string unZipDir)
        {
            unZipDir = unZipDir.EndsWith(@"\") ? unZipDir : unZipDir + @"\";
            var directoryInfo = new DirectoryInfo(unZipDir);
            if (!directoryInfo.Exists)
                directoryInfo.Create();
            var fileInfo = new FileInfo(zipFilePath);
            if (!fileInfo.Exists)
                return;
            using (var zipToOpen = new FileStream(zipFilePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
            {
                using (var archive = new ZipArchive(zipToOpen, ZipArchiveMode.Read))
                {
                    foreach (var zipArchiveEntry in archive.Entries)
                        if (!zipArchiveEntry.FullName.EndsWith("/"))
                        {
                            var entryFilePath = Regex.Replace(zipArchiveEntry.FullName.Replace("/", @"\"), @"^\\*", "");
                            var filePath = directoryInfo + entryFilePath; //设置解压路径
                            var content = new byte[zipArchiveEntry.Length];
                            zipArchiveEntry.Open().Read(content, 0, content.Length);

                            var greatFolder = Directory.GetParent(filePath);
                            if (!greatFolder.Exists)
                                greatFolder.Create();
                            File.WriteAllBytes(filePath, content);
                        }
                }
            }
        }

        public static void Compress(DirectoryInfo directorySelected)
        {
            foreach (FileInfo fileToCompress in directorySelected.GetFiles())
            {
                using (FileStream originalFileStream = fileToCompress.OpenRead())
                {
                    if ((File.GetAttributes(fileToCompress.FullName) &
                       FileAttributes.Hidden) != FileAttributes.Hidden & fileToCompress.Extension != ".gz")
                    {
                        using (FileStream compressedFileStream = File.Create(fileToCompress.FullName + ".gz"))
                        {
                            using (GZipStream compressionStream = new GZipStream(compressedFileStream,
                               CompressionMode.Compress))
                            {
                                originalFileStream.CopyTo(compressionStream);
                            }
                        }
                        //FileInfo info = new FileInfo(directoryPath + Path.DirectorySeparatorChar + fileToCompress.Name + ".gz");
                        //Console.WriteLine($"Compressed {fileToCompress.Name} from {fileToCompress.Length.ToString()} to {info.Length.ToString()} bytes.");
                    }
                }
            }
        }

        public static void Decompress(FileInfo fileToDecompress)
        {
            using (FileStream originalFileStream = fileToDecompress.OpenRead())
            {
                string currentFileName = fileToDecompress.FullName;
                string newFileName = currentFileName.Remove(currentFileName.Length - fileToDecompress.Extension.Length);

                using (FileStream decompressedFileStream = File.Create(newFileName))
                {
                    decompressedFileStream.Seek(0, SeekOrigin.Begin);
                    using (GZipStream decompressionStream = new GZipStream(originalFileStream, CompressionMode.Decompress))
                    {
                        decompressionStream.CopyTo(decompressedFileStream);
                        //Console.WriteLine($"Decompressed: {fileToDecompress.Name}");
                    }
                }
            }
        }
    }

 

API 返回压缩文件：

                var files = _sysFileService.GetFileByWorkOrder(dto, out error);
                if (!string.IsNullOrWhiteSpace(error))
                {
                    return new ResponseMessageResult(Request.CreateErrorResponse((HttpStatusCode)422, new HttpError(error)));
                }

                if (files == null || files.Count == 0)
                {
                    return new ResponseMessageResult(Request.CreateErrorResponse((HttpStatusCode)422, new HttpError("文件不存在")));
                }

                var fileFullName = $@"{GlobalConfig.DownLoadTempPath}\FileTemplates_{DateTime.Now.ToString("yyyyMMddHHmmss.fff")}.zip";
                MemoryStream stream = CompressHelper.CompresstoZipStreamUseZipArchive(fileFullName,
                    files.ToDictionary(r => r.Key, r => r.Value));

                var extenstion = ".zip";
                HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
                response.Content = new StreamContent(stream);
                response.Content.Headers.ContentType = new MediaTypeHeaderValue($@"application/*{extenstion}");
                response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
                {
                    FileName = Path.GetFileName(fileFullName)
                };
                return ResponseMessage(response);

 

客户端接收文件：

        /// <summary>
        /// 下载文件
        /// </summary>
        /// <param name="uri">资源网址</param>
        /// <param name="data"></param>
        /// <param name="localPath">要保存到本地的目录路径 如：C://Download/</param>
        /// <returns></returns>
        public bool DownLoad(string uri, object data, string localPath)
        {
            if (!Directory.Exists(localPath)) Directory.CreateDirectory(localPath);

            //删除旧文件
            DelectDir(localPath);

            //备份旧文件
            //BackTemplateFiles()

            // 发起请求并异步等待结果
            var httpClient = new HttpClient();

            string content = JsonConvert.SerializeObject(data);
            var buffer = Encoding.UTF8.GetBytes(content);
            var byteContent = new ByteArrayContent(buffer);
            byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            var responseMessage = httpClient.PostAsync(uri, byteContent).Result;

            if (responseMessage.IsSuccessStatusCode)
            {
                //下载压缩文件
                string fileFullName = $@"{localPath}\{responseMessage.Content.Headers.ContentDisposition.FileName}";
                using (var fs = File.Create(fileFullName))
                {
                    // 获取结果，并转成 stream 保存到本地。
                    var streamFromService = responseMessage.Content.ReadAsStreamAsync().Result;
                    streamFromService.CopyTo(fs);
                    fs.Close();
                    fs.Dispose();
                }

                //解压缩文件
                CompressHelper.DecompressUseZipArchive(fileFullName, localPath);

                //删除压缩文件
                File.Delete(fileFullName);
                ShowMessage(@"下载模板文件成功", Color.Green, _defaultFont);
                return true;
            }
            ShowMessage("下载模板文件失败，如果本站不需要下载模板文件，请忽略。", Color.Red, _defaultFont);
            ShowResult(responseMessage);
            return false;
        }