C# 递归压缩服务器文件夹及文件并下载

一、引入js文件

 <script src="../js/jquery-2.1.1.min.js"></script>
 <script src="../layui/layui.js"></script>

二、创建下载页面

<div class="askWrap">
   <span class="askBtn-3" onclick="downloadFile()">文件下载</span>
</div>

三、创建ajax请求

  function downloadFile() {
            var applicationPath = window.applicationPath === "" ? "" : window.applicationPath || "..";
            $.ajax({
                url: 'DownLoadFile.ashx',
                type: 'post',
                dataType: "json",
                beforeSend: function () {
                    //this.layerIndex = layer.load(0, { shade: [0.5, '#393D49'] });
                    loadid = xtip.load('文件打包中...', { lock: true })
                },
                success: function (data) {
                    xtip.close(loadid);
                    console.log(data)
                    if (data.code == '-100') {
                        alert(data.message);
                        //xtip.msg(data.message);//失败的表情
                    } else {
                        xtip.msg(data.message, { icon: 's' });
                        url = data.url;
                        window.open(applicationPath + url);
                    }
                },
            });
        }

四、后台程序处理

<%@ WebHandler Language="C#" Class="DownLoadFile" %>

using System;
using System.Web;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Web.SessionState;
using ICSharpCode.SharpZipLib;
using ICSharpCode.SharpZipLib.Zip;
using ICSharpCode.SharpZipLib.Checksums;
using ICSharpCode.SharpZipLib.Core;

public class DownLoadFile : IHttpHandler, IRequiresSessionState
{

    public void ProcessRequest(HttpContext context)
    {
        context.Response.ContentType = "text/plain";
        ResultInfo ResultInfos = new ResultInfo();
        string json = string.Empty;
        string fileName = string.Empty;
        try
        {
            //待压缩的文件或文件夹，全路径格式
            string FolderToZip = HttpContext.Current.Server.MapPath("/DownLoad/下载文件/");
            //压缩后生成的压缩文件名，全路径格式
            string ZipedFile = HttpContext.Current.Server.MapPath("/DownLoad/自定义文件名.zip");
            Zip(FolderToZip, ZipedFile);
            ResultInfos.code = 1;
            ResultInfos.message = "打包完成";
            ResultInfos.url = "/DownLoad/自定义文件名.zip";
            //返回结果
        }
        catch (Exception ex)
        {
            ResultInfos.code = -100;
            ResultInfos.message = ex.Message.ToString();
            json = JsonHelper.ObjectToJSON<ResultInfo>(ResultInfos);
            context.Response.Write(json);
            return;
        }
        json = JsonHelper.ObjectToJSON<ResultInfo>(ResultInfos);
        context.Response.Write(json);
    }

    [Serializable()]
    public struct ResultInfo
    {
        public string message;
        public int code;
        public string url;
    }
    public bool IsReusable
    {
        get
        {
            return false;
        }
    }

    public void DownLoad(string savePath, string downFileUrl)
    {
        Stream srm = null;
        StreamReader srmReader = null;
        FileStream fileFileStream = null;
        bool flag = true;
        try
        {
            WebClient wcClient = new WebClient();
            WebRequest webReq = WebRequest.Create(downFileUrl);
            WebResponse webRes = webReq.GetResponse();
            long fileLength = webRes.ContentLength;

            srm = webRes.GetResponseStream();
            srmReader = new StreamReader(srm);

            byte[] bufferbyte = new byte[fileLength];
            int allByte = (int)bufferbyte.Length;
            int startByte = 0;
            while (fileLength > 0)
            {
                //Application.DoEvents();
                int downByte = srm.Read(bufferbyte, startByte, allByte);
                if (downByte == 0) { break; };
                startByte += downByte;
                allByte -= downByte;
            }
            if (File.Exists(savePath))
            {
                File.Delete(savePath);
            }
            if (!File.Exists(savePath))
            {
                string[] dirArray = savePath.Split('\\');
                string temp = string.Empty;
                for (int i = 0; i < dirArray.Length - 1; i++)
                {
                    temp += dirArray[i].Trim() + "\\";
                    if (!Directory.Exists(temp))
                        Directory.CreateDirectory(temp);
                }
            }
            fileFileStream = new FileStream(savePath, FileMode.OpenOrCreate, FileAccess.Write);
            fileFileStream.Write(bufferbyte, 0, bufferbyte.Length);
        }
        catch (WebException ex)
        {
            throw ex;
        }
        finally
        {
            if (srm != null) { srm.Close(); }
            if (srmReader != null) { srmReader.Close(); }
            if (fileFileStream != null) { fileFileStream.Close(); }
        }
    }
    //需要引用到 ICSharpCode.SharpZipLib 类库来实现文件压缩，你可以通过Nuget来安装此类库，或者到搜索引擎去搜索并下载添加到项目引用

    #region 压缩文件
    /// 递归压缩文件夹方法 
    private bool ZipFileDictory(string FolderToZip, ZipOutputStream s, string ParentFolderName)
    {
        bool res = true;
        string[] folders, filenames;
        ZipEntry entry = null;
        FileStream fs = null;
        Crc32 crc = new Crc32();

        try
        {

            //创建当前文件夹
            entry = new ZipEntry(Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip) + "/")); //加上 “/” 才会当成是文件夹创建
            s.PutNextEntry(entry);
            s.Flush();
            //先压缩文件，再递归压缩文件夹 
            filenames = Directory.GetFiles(FolderToZip);
            foreach (string file in filenames)
            {

                //打开压缩文件
                fs = File.OpenRead(file);
                if (fs.Length != 0)
                {
                    byte[] buffer = new byte[fs.Length];
                    fs.Read(buffer, 0, buffer.Length);
                    entry = new ZipEntry(Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip) + "/" + Path.GetFileName(file)));

                    entry.DateTime = DateTime.Now;
                    entry.Size = fs.Length;
                    fs.Close();

                    crc.Reset();
                    crc.Update(buffer);

                    entry.Crc = crc.Value;

                    s.PutNextEntry(entry);

                    s.Write(buffer, 0, buffer.Length);
                }

            }
        }
        catch
        {
            res = false;
        }
        finally
        {
            if (fs != null)
            {
                fs.Close();
                fs = null;
            }
            if (entry != null)
            {
                entry = null;
            }
            GC.Collect();
            GC.Collect(1);
        }


        folders = Directory.GetDirectories(FolderToZip);
        foreach (string folder in folders)
        {
            if (!ZipFileDictory(folder, s, Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip))))
            {
                return false;
            }
        }

        return res;
    }

    /// <summary>
    /// 压缩目录
    /// </summary>
    /// <param name="FolderToZip">待压缩的文件夹，全路径格式</param>
    /// <param name="ZipedFile">压缩后的文件名，全路径格式</param>
    /// <param name="Password"></param>
    /// <returns></returns>
    private bool ZipFileDictory1(string FolderToZip, string ZipedFile, String Password)
    {
        bool res;
        if (!Directory.Exists(FolderToZip))
        {
            return false;
        }

        ZipOutputStream s = new ZipOutputStream(File.Create(ZipedFile));
        s.SetLevel(6);

        res = ZipFileDictory(FolderToZip, s, "");

        s.Finish();
        s.Close();

        return res;
    }

    /// <summary>
    /// 压缩文件
    /// </summary>
    /// <param name="FileToZip">要进行压缩的文件名</param>
    /// <param name="ZipedFile">压缩后生成的压缩文件名</param>
    /// <param name="Password"></param>
    /// <returns></returns>
    private bool ZipFile(string FileToZip, string ZipedFile)
    {
        //如果文件没有找到，则报错
        if (!File.Exists(FileToZip))
        {
            throw new System.IO.FileNotFoundException("指定要压缩的文件: " + FileToZip + " 不存在!");
        }
        //FileStream fs = null;
        FileStream ZipFile = null;
        ZipOutputStream ZipStream = null;
        ZipEntry ZipEntry = null;

        bool res = true;
        try
        {
            ZipFile = File.OpenRead(FileToZip);
            byte[] buffer = new byte[ZipFile.Length];
            ZipFile.Read(buffer, 0, buffer.Length);
            ZipFile.Close();

            ZipFile = File.Create(ZipedFile);
            ZipStream = new ZipOutputStream(ZipFile);
            ZipEntry = new ZipEntry(Path.GetFileName(FileToZip));
            ZipStream.PutNextEntry(ZipEntry);
            ZipStream.SetLevel(6);

            ZipStream.Write(buffer, 0, buffer.Length);
        }
        catch
        {
            res = false;
        }
        finally
        {
            if (ZipEntry != null)
            {
                ZipEntry = null;
            }
            if (ZipStream != null)
            {
                ZipStream.Finish();
                ZipStream.Close();
            }
            if (ZipFile != null)
            {
                ZipFile.Close();
                ZipFile = null;
            }
            GC.Collect();
            GC.Collect(1);
        }

        return res;
    }

    /// <summary>
    /// 压缩文件 和 文件夹
    /// </summary>
    /// <param name="FileToZip">待压缩的文件或文件夹，全路径格式</param>
    /// <param name="ZipedFile">压缩后生成的压缩文件名，全路径格式</param>
    /// <param name="Password"></param>
    /// <returns></returns>
    private bool Zip(String FileToZip, String ZipedFile)
    {
        if (Directory.Exists(FileToZip))
        {
            return ZipFileDictory1(FileToZip, ZipedFile, "");
        }
        else if (File.Exists(FileToZip))
        {
            return ZipFile(FileToZip, ZipedFile);
        }
        else
        {
            return false;
        }
    }
    #endregion

    #region 解压文件
    /// <summary>
    /// 解压功能(解压压缩文件到指定目录)
    /// </summary>
    /// <param name="FileToUpZip">待解压的文件</param>
    /// <param name="ZipedFolder">指定解压目标目录</param>
    /// <param name="Password"></param>
    private void UnZip(string FileToUpZip, string ZipedFolder, string Password)
    {
        if (!File.Exists(FileToUpZip))
        {
            return;
        }

        if (!Directory.Exists(ZipedFolder))
        {
            Directory.CreateDirectory(ZipedFolder);
        }

        ZipInputStream s = null;
        ZipEntry theEntry = null;

        string fileName;
        FileStream streamWriter = null;
        try
        {
            s = new ZipInputStream(File.OpenRead(FileToUpZip));
            s.Password = Password;
            while ((theEntry = s.GetNextEntry()) != null)
            {
                if (theEntry.Name != String.Empty)
                {
                    fileName = Path.Combine(ZipedFolder, theEntry.Name);
                    /**/
                    ///判断文件路径是否是文件夹
                    if (fileName.EndsWith("/") || fileName.EndsWith("\\"))
                    {
                        Directory.CreateDirectory(fileName);
                        continue;
                    }

                    streamWriter = File.Create(fileName);
                    int size = 2048;
                    byte[] data = new byte[2048];
                    while (true)
                    {
                        size = s.Read(data, 0, data.Length);
                        if (size > 0)
                        {
                            streamWriter.Write(data, 0, size);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
        }
        finally
        {
            if (streamWriter != null)
            {
                streamWriter.Close();
                streamWriter = null;
            }
            if (theEntry != null)
            {
                theEntry = null;
            }
            if (s != null)
            {
                s.Close();
                s = null;
            }
            GC.Collect();
            GC.Collect(1);
        }
    }
    #endregion



}