C#中ZipHelper 压缩和解压帮助类

关于本文档的说明

　　本文档基于icsharpcode.sharpziplib.dll的封装，常用的解压和压缩方法都已经涵盖在内，都是经过项目实战积累下来的

　　欢迎传播分享，必须保持原作者的信息，但禁止将该文档直接用于商业盈利。

　　本人自从几年前走上编程之路，一直致力于收集和总结出好用的框架和通用类库，不管是微软自己的还是第三方的只要实际项目中好用且可以解决实际问题那都会收集好，编写好文章和别人一起分享，这样自己学到了，别人也能学到知识，当今社会很需要知识的搬运工。

1.基本介绍

      由于项目中需要用到各种压缩将文件进行压缩下载，减少网络的带宽，所以压缩是一个非常常见的功能，对于压缩微软自己也提供了一些类库

微软自带压缩类ziparchive类，适合net framework4.5才可以使用
调用压缩软件命令执行压缩动作，这个就需要电脑本身安装压缩软件了
使用第三方的压缩dll文件，一般使用最多的是（icsharpcode.sharpziplib.dll），下载dll icsharpcode.sharpziplib.zip

2.实际项目

压缩单个文件，需要指定压缩等级
压缩单个文件夹，需要指定压缩等级
压缩多个文件或者多个文件夹
对压缩包进行加密【用的较少，实际情况也有】

2.1 压缩单个文件

写了两个方法，可以指定压缩等级，这样你的压缩包大小就不一样了

2.2 压缩单个文件夹

public void zipdir(string dirtozip, string zipedfilename, int compressionlevel = 9)

2.3 压缩多个文件或者文件夹

public bool zipmanyfilesordictorys(ienumerable<string> folderorfilelist, string zipedfile, string password)

2.4 对压缩包进行加密

public bool zipmanyfilesordictorys(ienumerable<string> folderorfilelist, string zipedfile, string password)

2.5 直接解压，无需密码

public void unzip(string zipfilepath, string unzipdir)

3.演示图　

 

3.ziphelper源码

//-------------------------------------------------------------------------------------
// all rights reserved , copyright (c) 2016 , zto , ltd .
//-------------------------------------------------------------------------------------

using system;
using system.collections;
using system.collections.generic;
using system.io;

namespace zto.pictest.utilities
{
  using icsharpcode.sharpziplib.checksums;
  using icsharpcode.sharpziplib.zip;

  /// <summary>
  /// zip压缩帮助类
  ///
  /// 修改纪录
  ///
  ///    2015-09-16 版本：1.0 yanghenglian 创建主键，注意命名空间的排序。
  ///   2016-5-7 yanghenglian增加了可以支持多个文件或者多个文件夹打包成一个zip文件
  /// 
  /// 版本：1.0
  ///
  /// <author>
  ///    <name>yanghenglian</name>
  ///    <date>2015-09-16</date>
  /// </author>
  /// </summary>
  public class ziphelper
  {
    /// <summary>
    /// 压缩文件夹
    /// </summary>
    /// <param name="dirtozip"></param>
    /// <param name="zipedfilename"></param>
    /// <param name="compressionlevel">压缩率0（无压缩）9（压缩率最高）</param>
    public void zipdir(string dirtozip, string zipedfilename, int compressionlevel = 9)
    {
      if (path.getextension(zipedfilename) != ".zip")
      {
        zipedfilename = zipedfilename + ".zip";
      }
      using (var zipoutputstream = new zipoutputstream(file.create(zipedfilename)))
      {
        zipoutputstream.setlevel(compressionlevel);
        crc32 crc = new crc32();
        hashtable filelist = getallfies(dirtozip);
        foreach (dictionaryentry item in filelist)
        {
          filestream fs = new filestream(item.key.tostring(), filemode.open, fileaccess.read, fileshare.readwrite);
          byte[] buffer = new byte[fs.length];
          fs.read(buffer, 0, buffer.length);
          // zipentry entry = new zipentry(item.key.tostring().substring(dirtozip.length + 1));
          zipentry entry = new zipentry(path.getfilename(item.key.tostring()))
                   {
                     datetime = (datetime) item.value,
                     size = fs.length
                   };
          fs.close();
          crc.reset();
          crc.update(buffer);
          entry.crc = crc.value;
          zipoutputstream.putnextentry(entry);
          zipoutputstream.write(buffer, 0, buffer.length);
        }
      }
    }

    /// <summary> 
    /// 获取所有文件 
    /// </summary> 
    /// <returns></returns> 
    public hashtable getallfies(string dir)
    {
      hashtable fileslist = new hashtable();
      directoryinfo filedire = new directoryinfo(dir);
      if (!filedire.exists)
      {
        throw new filenotfoundexception("目录:" + filedire.fullname + "没有找到!");
      }

      getalldirfiles(filedire, fileslist);
      getalldirsfiles(filedire.getdirectories(), fileslist);
      return fileslist;
    }

    /// <summary> 
    /// 获取一个文件夹下的所有文件夹里的文件 
    /// </summary> 
    /// <param name="dirs"></param> 
    /// <param name="fileslist"></param> 
    public void getalldirsfiles(ienumerable<directoryinfo> dirs, hashtable fileslist)
    {
      foreach (directoryinfo dir in dirs)
      {
        foreach (fileinfo file in dir.getfiles("*.*"))
        {
          fileslist.add(file.fullname, file.lastwritetime);
        }
        getalldirsfiles(dir.getdirectories(), fileslist);
      }
    }

    /// <summary> 
    /// 获取一个文件夹下的文件 
    /// </summary> 
    /// <param name="dir">目录名称</param>
    /// <param name="fileslist">文件列表hasttable</param> 
    public static void getalldirfiles(directoryinfo dir, hashtable fileslist)
    {
      foreach (fileinfo file in dir.getfiles("*.*"))
      {
        fileslist.add(file.fullname, file.lastwritetime);
      }
    }

    /// <summary> 
    /// 功能：解压zip格式的文件。 
    /// </summary> 
    /// <param name="zipfilepath">压缩文件路径</param> 
    /// <param name="unzipdir">解压文件存放路径,为空时默认与压缩文件同一级目录下，跟压缩文件同名的文件夹</param> 
    /// <returns>解压是否成功</returns> 
    public void unzip(string zipfilepath, string unzipdir)
    {
      if (zipfilepath == string.empty)
      {
        throw new exception("压缩文件不能为空！");
      }
      if (!file.exists(zipfilepath))
      {
        throw new filenotfoundexception("压缩文件不存在！");
      }
      //解压文件夹为空时默认与压缩文件同一级目录下，跟压缩文件同名的文件夹 
      if (unzipdir == string.empty)
        unzipdir = zipfilepath.replace(path.getfilename(zipfilepath), path.getfilenamewithoutextension(zipfilepath));
      if (!unzipdir.endswith("/"))
        unzipdir += "/";
      if (!directory.exists(unzipdir))
        directory.createdirectory(unzipdir);

      using (var s = new zipinputstream(file.openread(zipfilepath)))
      {

        zipentry theentry;
        while ((theentry = s.getnextentry()) != null)
        {
          string directoryname = path.getdirectoryname(theentry.name);
          string filename = path.getfilename(theentry.name);
          if (!string.isnullorempty(directoryname))
          {
            directory.createdirectory(unzipdir + directoryname);
          }
          if (directoryname != null && !directoryname.endswith("/"))
          {
          }
          if (filename != string.empty)
          {
            using (filestream streamwriter = file.create(unzipdir + theentry.name))
            {

              int size;
              byte[] data = new byte[2048];
              while (true)
              {
                size = s.read(data, 0, data.length);
                if (size > 0)
                {
                  streamwriter.write(data, 0, size);
                }
                else
                {
                  break;
                }
              }
            }
          }
        }
      }
    }

    /// <summary>
    /// 压缩单个文件
    /// </summary>
    /// <param name="filepath">被压缩的文件名称(包含文件路径)，文件的全路径</param>
    /// <param name="zipedfilename">压缩后的文件名称(包含文件路径)，保存的文件名称</param>
    /// <param name="compressionlevel">压缩率0（无压缩）到 9（压缩率最高）</param>
    public void zipfile(string filepath, string zipedfilename, int compressionlevel = 9)
    {
      // 如果文件没有找到，则报错 
      if (!file.exists(filepath))
      {
        throw new filenotfoundexception("文件：" + filepath + "没有找到！");
      }
      // 如果压缩后名字为空就默认使用源文件名称作为压缩文件名称
      if (string.isnullorempty(zipedfilename))
      {
        string oldvalue = path.getfilename(filepath);
        if (oldvalue != null)
        {
          zipedfilename = filepath.replace(oldvalue, "") + path.getfilenamewithoutextension(filepath) + ".zip";
        }
      }
      // 如果压缩后的文件名称后缀名不是zip，就是加上zip，防止是一个乱码文件
      if (path.getextension(zipedfilename) != ".zip")
      {
        zipedfilename = zipedfilename + ".zip";
      }
      // 如果指定位置目录不存在，创建该目录 c:\users\yhl\desktop\大汉三通
      string zipeddir = zipedfilename.substring(0, zipedfilename.lastindexof("\\", stringcomparison.ordinal));
      if (!directory.exists(zipeddir))
      {
        directory.createdirectory(zipeddir);
      }
      // 被压缩文件名称
      string filename = filepath.substring(filepath.lastindexof("\\", stringcomparison.ordinal) + 1);
      var streamtozip = new filestream(filepath, filemode.open, fileaccess.read);
      var zipfile = file.create(zipedfilename);
      var zipstream = new zipoutputstream(zipfile);
      var zipentry = new zipentry(filename);
      zipstream.putnextentry(zipentry);
      zipstream.setlevel(compressionlevel);
      var buffer = new byte[2048];
      int32 size = streamtozip.read(buffer, 0, buffer.length);
      zipstream.write(buffer, 0, size);
      try
      {
        while (size < streamtozip.length)
        {
          int sizeread = streamtozip.read(buffer, 0, buffer.length);
          zipstream.write(buffer, 0, sizeread);
          size += sizeread;
        }
      }
      finally
      {
        zipstream.finish();
        zipstream.close();
        streamtozip.close();
      }
    }

    /// <summary> 
    /// 压缩单个文件 
    /// </summary> 
    /// <param name="filetozip">要进行压缩的文件名，全路径</param> 
    /// <param name="zipedfile">压缩后生成的压缩文件名,全路径</param> 
    public void zipfile(string filetozip, string zipedfile)
    {
      // 如果文件没有找到，则报错 
      if (!file.exists(filetozip))
      {
        throw new filenotfoundexception("指定要压缩的文件: " + filetozip + " 不存在!");
      }
      using (filestream filestream = file.openread(filetozip))
      {
        byte[] buffer = new byte[filestream.length];
        filestream.read(buffer, 0, buffer.length);
        filestream.close();
        using (filestream zipfile = file.create(zipedfile))
        {
          using (zipoutputstream zipoutputstream = new zipoutputstream(zipfile))
          {
            // string filename = filetozip.substring(filetozip.lastindexof("\\") + 1);
            string filename = path.getfilename(filetozip);
            var zipentry = new zipentry(filename)
            {
              datetime = datetime.now,
              isunicodetext = true
            };
            zipoutputstream.putnextentry(zipentry);
            zipoutputstream.setlevel(5);
            zipoutputstream.write(buffer, 0, buffer.length);
            zipoutputstream.finish();
            zipoutputstream.close();
          }
        }
      }
    }

    /// <summary>
    /// 压缩多个目录或文件
    /// </summary>
    /// <param name="folderorfilelist">待压缩的文件夹或者文件，全路径格式,是一个集合</param>
    /// <param name="zipedfile">压缩后的文件名，全路径格式</param>
    /// <param name="password">压宿密码</param>
    /// <returns></returns>
    public bool zipmanyfilesordictorys(ienumerable<string> folderorfilelist, string zipedfile, string password)
    {
      bool res = true;
      using (var s = new zipoutputstream(file.create(zipedfile)))
      {
        s.setlevel(6);
        if (!string.isnullorempty(password))
        {
          s.password = password;
        }
        foreach (string fileordir in folderorfilelist)
        {
          //是文件夹
          if (directory.exists(fileordir))
          {
            res = zipfiledictory(fileordir, s, "");
          }
          else
          {
            //文件
            res = zipfilewithstream(fileordir, s);
          }
        }
        s.finish();
        s.close();
        return res;
      }
    }

    /// <summary>
    /// 带压缩流压缩单个文件
    /// </summary>
    /// <param name="filetozip">要进行压缩的文件名</param>
    /// <param name="zipstream"></param>
    /// <returns></returns>
    private bool zipfilewithstream(string filetozip, zipoutputstream zipstream)
    {
      //如果文件没有找到，则报错
      if (!file.exists(filetozip))
      {
        throw new filenotfoundexception("指定要压缩的文件: " + filetozip + " 不存在!");
      }
      //filestream fs = null;
      filestream zipfile = 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();
        zipentry = new zipentry(path.getfilename(filetozip));
        zipstream.putnextentry(zipentry);
        zipstream.write(buffer, 0, buffer.length);
      }
      catch
      {
        res = false;
      }
      finally
      {
        if (zipentry != null)
        {
        }

        if (zipfile != null)
        {
          zipfile.close();
        }
        gc.collect();
        gc.collect(1);
      }
      return res;

    }

    /// <summary>
    /// 递归压缩文件夹方法
    /// </summary>
    /// <param name="foldertozip"></param>
    /// <param name="s"></param>
    /// <param name="parentfoldername"></param>
    private bool zipfiledictory(string foldertozip, zipoutputstream s, string parentfoldername)
    {
      bool res = true;
      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();
        //先压缩文件，再递归压缩文件夹
        var filenames = directory.getfiles(foldertozip);
        foreach (string file in filenames)
        {
          //打开压缩文件
          fs = file.openread(file);
          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();
        }
        if (entry != null)
        {
        }
        gc.collect();
        gc.collect(1);
      }
      var folders = directory.getdirectories(foldertozip);
      foreach (string folder in folders)
      {
        if (!zipfiledictory(folder, s, path.combine(parentfoldername, path.getfilename(foldertozip))))
        {
          return false;
        }
      }
      return res;
    }
  }
}

 慢慢积累，你的这些代码都是你的财富，可以帮你提高工作效率，勤勤恳恳的干好每件事情，点滴积累，开心编程。