转自园友：jimcsharp的博文C#实现Zip压缩解压实例【转】

在此基础上，对其中的压缩文件夹方法略作修正，并增加是否对父文件夹进行压缩的方法。（因为笔者有只压缩文件夹下的所有文件，却不想将选中的文件夹打入压缩文件的需求），话不多说，上代码：
其中需要依赖ICSharpCode.SharpZipLib.dll:

之后，新建一个类，代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.IO;
  6. using ICSharpCode.SharpZipLib;
  7. using ICSharpCode.SharpZipLib.Zip;
  8. using ICSharpCode.SharpZipLib.Checksums;
  9.  
  10. namespace Zip.Util
  11. {
  12.     /// <summary>
  13.     /// 适用与ZIP压缩
  14.     /// </summary>
  15.     public class ZipHelper
  16.     {
  17.         #region 压缩
  18.  
  19.         /// <summary>
  20.         /// 递归压缩文件夹的内部方法
  21.         /// </summary>
  22.         /// <param name="folderToZip">要压缩的文件夹路径</param>
  23.         /// <param name="zipStream">压缩输出流</param>
  24.         /// <param name="parentFolderName">此文件夹的上级文件夹</param>
  25.         /// <returns></returns>
  26.         private static bool ZipDirectory(string folderToZip, ZipOutputStream zipStream, string parentFolderName)
  27.         {
  28.             bool result = true;
  29.             string[] folders, files;
  30.             ZipEntry ent = null;
  31.             FileStream fs = null;
  32.             Crc32 crc = new Crc32();
  33.  
  34.             try
  35.             {
  36.                 ent = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/"));
  37.                 zipStream.PutNextEntry(ent);
  38.                 zipStream.Flush();
  39.  
  40.                 files = Directory.GetFiles(folderToZip);
  41.                 foreach (string file in files)
  42.                 {
  43.                     fs = File.OpenRead(file);
  44.  
  45.                     byte[] buffer = new byte[fs.Length];
  46.                     fs.Read(buffer, , buffer.Length);
  47.                     ent = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/" + Path.GetFileName(file)));
  48.                     ent.DateTime = DateTime.Now;
  49.                     ent.Size = fs.Length;
  50.  
  51.                     fs.Close();
  52.  
  53.                     crc.Reset();
  54.                     crc.Update(buffer);
  55.  
  56.                     ent.Crc = crc.Value;
  57.                     zipStream.PutNextEntry(ent);
  58.                     zipStream.Write(buffer, , buffer.Length);
  59.                 }
  60.  
  61.             }
  62.             catch
  63.             {
  64.                 result = false;
  65.             }
  66.             finally
  67.             {
  68.                 if (fs != null)
  69.                 {
  70.                     fs.Close();
  71.                     fs.Dispose();
  72.                 }
  73.                 if (ent != null)
  74.                 {
  75.                     ent = null;
  76.                 }
  77.                 GC.Collect();
  78.                 GC.Collect();
  79.             }
  80.  
  81.             folders = Directory.GetDirectories(folderToZip);
  82.             foreach (string folder in folders)
  83.                 if (!ZipDirectory(folder, zipStream, Path.GetFileName(folderToZip)))
  84.                     return false;
  85.  
  86.             return result;
  87.         }
  88.  
  89.         /// <summary>
  90.         /// 私有方法，增加是否包含父文件夹方法
  91.         /// </summary>
  92.         /// <param name="folderToZip">要压缩的文件夹路径</param>
  93.         /// <param name="zipStream">压缩输出流</param>
  94.         /// <param name="ContainParent">是否包含父文件夹</param>
  95.         /// <returns></returns>
  96.         private static bool ZipDirectory(string folderToZip, ZipOutputStream zipStream, Boolean ContainParent)
  97.         {
  98.             string[] folders, files;
  99.             ZipEntry ent = null;
  100.             FileStream fs = null;
  101.             Crc32 crc = new Crc32();
  102.  
  103.             try
  104.             {
  105.  
  106.                 if (ContainParent)
  107.                 {
  108.                     ent = new ZipEntry(Path.GetFileName(folderToZip) + "/");
  109.                     zipStream.PutNextEntry(ent);
  110.                     zipStream.Flush();
  111.                 }
  112.  
  113.                 files = Directory.GetFiles(folderToZip);
  114.                 foreach (string file in files)
  115.                 {
  116.                     fs = File.OpenRead(file);
  117.  
  118.                     byte[] buffer = new byte[fs.Length];
  119.                     fs.Read(buffer, , buffer.Length);
  120.  
  121.                     if (ContainParent)
  122.                     {
  123.                         ent = new ZipEntry(Path.GetFileName(folderToZip) + "/" + Path.GetFileName(file));
  124.                     }
  125.                     else
  126.                     {
  127.                         ent = new ZipEntry(Path.GetFileName(file));
  128.                     }
  129.  
  130.                     ent.DateTime = DateTime.Now;
  131.                     ent.Size = fs.Length;
  132.  
  133.                     fs.Close();
  134.  
  135.                     crc.Reset();
  136.                     crc.Update(buffer);
  137.  
  138.                     ent.Crc = crc.Value;
  139.                     zipStream.PutNextEntry(ent);
  140.                     zipStream.Write(buffer, , buffer.Length);
  141.                 }
  142.  
  143.             }
  144.             catch
  145.             {
  146.                 return false;
  147.             }
  148.             finally
  149.             {
  150.                 if (fs != null)
  151.                 {
  152.                     fs.Close();
  153.                     fs.Dispose();
  154.                 }
  155.                 if (ent != null)
  156.                 {
  157.                     ent = null;
  158.                 }
  159.                 GC.Collect();
  160.                 GC.Collect();
  161.             }
  162.  
  163.             folders = Directory.GetDirectories(folderToZip);
  164.  
  165.             if (ContainParent)
  166.             {
  167.                 foreach (string folder in folders)
  168.                     if (!ZipDirectory(folder, zipStream, Path.GetFileName(folderToZip)))
  169.                         return false;
  170.             }
  171.             else
  172.             {
  173.                 foreach (string folder in folders)
  174.                     if (!ZipDirectory(folder, zipStream, ""))
  175.                         return false;
  176.             }
  177.  
  178.             return true;
  179.         }
  180.  
  181.         /// <summary>
  182.         /// 生成Zip
  183.         /// </summary>
  184.         /// <param name="folderToZip"></param>
  185.         /// <param name="zipedFile"></param>
  186.         /// <param name="IncludeParent">是否包含父文件夹</param>
  187.         /// <returns></returns>
  188.         public static bool ZipDirectory(string folderToZip, string zipedFile, Boolean IncludeParent)
  189.         {
  190.             bool result = false;
  191.             if (!Directory.Exists(folderToZip))
  192.                 return result;
  193.  
  194.             ZipOutputStream zipStream = new ZipOutputStream(File.Create(zipedFile));
  195.             zipStream.SetLevel();
  196.  
  197.             result = ZipDirectory(folderToZip, zipStream, IncludeParent);
  198.  
  199.             zipStream.Finish();
  200.             zipStream.Close();
  201.  
  202.             return result;
  203.         }
  204.  
  205.         /// <summary>
  206.         /// 压缩文件夹
  207.         /// </summary>
  208.         /// <param name="folderToZip">要压缩的文件夹路径</param>
  209.         /// <param name="zipedFile">压缩文件完整路径</param>
  210.         /// <param name="password">密码</param>
  211.         /// <returns>是否压缩成功</returns>
  212.         public static bool ZipDirectory(string folderToZip, string zipedFile, string password)
  213.         {
  214.             bool result = false;
  215.             if (!Directory.Exists(folderToZip))
  216.                 return result;
  217.  
  218.             ZipOutputStream zipStream = new ZipOutputStream(File.Create(zipedFile));
  219.             zipStream.SetLevel();
  220.             if (!string.IsNullOrEmpty(password)) zipStream.Password = password;
  221.  
  222.             result = ZipDirectory(folderToZip, zipStream, "");
  223.  
  224.             zipStream.Finish();
  225.             zipStream.Close();
  226.  
  227.             return result;
  228.         }
  229.  
  230.         /// <summary>
  231.         /// 压缩文件夹
  232.         /// </summary>
  233.         /// <param name="folderToZip">要压缩的文件夹路径</param>
  234.         /// <param name="zipedFile">压缩文件完整路径</param>
  235.         /// <returns>是否压缩成功</returns>
  236.         public static bool ZipDirectory(string folderToZip, string zipedFile)
  237.         {
  238.             bool result = ZipDirectory(folderToZip, zipedFile, null);
  239.             return result;
  240.         }
  241.  
  242.         /// <summary>
  243.         /// 压缩文件
  244.         /// </summary>
  245.         /// <param name="fileToZip">要压缩的文件全名</param>
  246.         /// <param name="zipedFile">压缩后的文件名</param>
  247.         /// <param name="password">密码</param>
  248.         /// <returns>压缩结果</returns>
  249.         public static bool ZipFile(string fileToZip, string zipedFile, string password)
  250.         {
  251.             bool result = true;
  252.             ZipOutputStream zipStream = null;
  253.             FileStream fs = null;
  254.             ZipEntry ent = null;
  255.  
  256.             if (!File.Exists(fileToZip))
  257.                 return false;
  258.  
  259.             try
  260.             {
  261.                 fs = File.OpenRead(fileToZip);
  262.                 byte[] buffer = new byte[fs.Length];
  263.                 fs.Read(buffer, , buffer.Length);
  264.                 fs.Close();
  265.  
  266.                 fs = File.Create(zipedFile);
  267.                 zipStream = new ZipOutputStream(fs);
  268.                 if (!string.IsNullOrEmpty(password)) zipStream.Password = password;
  269.                 ent = new ZipEntry(Path.GetFileName(fileToZip));
  270.                 zipStream.PutNextEntry(ent);
  271.                 zipStream.SetLevel();
  272.  
  273.                 zipStream.Write(buffer, , buffer.Length);
  274.  
  275.             }
  276.             catch
  277.             {
  278.                 result = false;
  279.             }
  280.             finally
  281.             {
  282.                 if (zipStream != null)
  283.                 {
  284.                     zipStream.Finish();
  285.                     zipStream.Close();
  286.                 }
  287.                 if (ent != null)
  288.                 {
  289.                     ent = null;
  290.                 }
  291.                 if (fs != null)
  292.                 {
  293.                     fs.Close();
  294.                     fs.Dispose();
  295.                 }
  296.             }
  297.             GC.Collect();
  298.             GC.Collect();
  299.  
  300.             return result;
  301.         }
  302.  
  303.         /// <summary>
  304.         /// 压缩文件
  305.         /// </summary>
  306.         /// <param name="fileToZip">要压缩的文件全名</param>
  307.         /// <param name="zipedFile">压缩后的文件名</param>
  308.         /// <returns>压缩结果</returns>
  309.         public static bool ZipFile(string fileToZip, string zipedFile)
  310.         {
  311.             bool result = ZipFile(fileToZip, zipedFile, null);
  312.             return result;
  313.         }
  314.  
  315.         /// <summary>
  316.         /// 压缩文件或文件夹
  317.         /// </summary>
  318.         /// <param name="fileToZip">要压缩的路径</param>
  319.         /// <param name="zipedFile">压缩后的文件名</param>
  320.         /// <param name="password">密码</param>
  321.         /// <returns>压缩结果</returns>
  322.         public static bool Zip(string fileToZip, string zipedFile, string password)
  323.         {
  324.             bool result = false;
  325.             if (Directory.Exists(fileToZip))
  326.                 result = ZipDirectory(fileToZip, zipedFile, password);
  327.             else if (File.Exists(fileToZip))
  328.                 result = ZipFile(fileToZip, zipedFile, password);
  329.  
  330.             return result;
  331.         }
  332.  
  333.         /// <summary>
  334.         /// 压缩文件或文件夹
  335.         /// </summary>
  336.         /// <param name="fileToZip">要压缩的路径</param>
  337.         /// <param name="zipedFile">压缩后的文件名</param>
  338.         /// <returns>压缩结果</returns>
  339.         public static bool Zip(string fileToZip, string zipedFile)
  340.         {
  341.             bool result = Zip(fileToZip, zipedFile, null);
  342.             return result;
  343.  
  344.         }
  345.  
  346.         #endregion
  347.  
  348.         #region 解压
  349.  
  350.         /// <summary>
  351.         /// 解压功能(解压压缩文件到指定目录)
  352.         /// </summary>
  353.         /// <param name="fileToUnZip">待解压的文件</param>
  354.         /// <param name="zipedFolder">指定解压目标目录</param>
  355.         /// <param name="password">密码</param>
  356.         /// <returns>解压结果</returns>
  357.         public static bool UnZip(string fileToUnZip, string zipedFolder, string password)
  358.         {
  359.             bool result = true;
  360.             FileStream fs = null;
  361.             ZipInputStream zipStream = null;
  362.             ZipEntry ent = null;
  363.             string fileName;
  364.  
  365.             if (!File.Exists(fileToUnZip))
  366.                 return false;
  367.  
  368.             if (!Directory.Exists(zipedFolder))
  369.                 Directory.CreateDirectory(zipedFolder);
  370.  
  371.             try
  372.             {
  373.                 zipStream = new ZipInputStream(File.OpenRead(fileToUnZip));
  374.                 if (!string.IsNullOrEmpty(password)) zipStream.Password = password;
  375.                 while ((ent = zipStream.GetNextEntry()) != null)
  376.                 {
  377.                     if (!string.IsNullOrEmpty(ent.Name))
  378.                     {
  379.                         fileName = Path.Combine(zipedFolder, ent.Name);
  380.                         fileName = fileName.Replace('/', '\\');//change by Mr.HopeGi   
  381.  
  382.                         if (fileName.EndsWith("\\"))
  383.                         {
  384.                             Directory.CreateDirectory(fileName);
  385.                             continue;
  386.                         }
  387.  
  388.                         fs = File.Create(fileName);
  389.                         int size = ;
  390.                         byte[] data = new byte[size];
  391.                         while (true)
  392.                         {
  393.                             size = zipStream.Read(data, , data.Length);
  394.                             if (size > )
  395.                                 fs.Write(data, , data.Length);
  396.                             else
  397.                                 break;
  398.                         }
  399.                     }
  400.                 }
  401.             }
  402.             catch
  403.             {
  404.                 result = false;
  405.             }
  406.             finally
  407.             {
  408.                 if (fs != null)
  409.                 {
  410.                     fs.Close();
  411.                     fs.Dispose();
  412.                 }
  413.                 if (zipStream != null)
  414.                 {
  415.                     zipStream.Close();
  416.                     zipStream.Dispose();
  417.                 }
  418.                 if (ent != null)
  419.                 {
  420.                     ent = null;
  421.                 }
  422.                 GC.Collect();
  423.                 GC.Collect();
  424.             }
  425.             return result;
  426.         }
  427.  
  428.         /// <summary>
  429.         /// 解压功能(解压压缩文件到指定目录)
  430.         /// </summary>
  431.         /// <param name="fileToUnZip">待解压的文件</param>
  432.         /// <param name="zipedFolder">指定解压目标目录</param>
  433.         /// <returns>解压结果</returns>
  434.         //public static bool UnZip(string fileToUnZip, string zipedFolder)
  435.         //{
  436.         //    bool result = UnZip(fileToUnZip, zipedFolder, null);
  437.         //    return result;
  438.         //}
  439.  
  440.         /// <summary>
  441.         /// 解压功能(解压压缩文件到指定目录)
  442.         /// </summary>
  443.         /// <param name="fileToUnZip">待解压的文件</param>
  444.         /// <param name="zipedFolder">指定解压目标目录</param>
  445.         /// <returns>解压结果</returns>
  446.         public static bool UnZip(string fileToUnZip, string zipedFolder)
  447.         {
  448.  
  449.             if (Directory.Exists(zipedFolder))
  450.             {
  451.                 Directory.Delete(zipedFolder, true);
  452.             }
  453.             Directory.CreateDirectory(zipedFolder);
  454.             ZipInputStream zipInputStream = new ZipInputStream(File.Open(fileToUnZip, FileMode.Open));
  455.             ZipEntry zipEntryFromZippedFile = zipInputStream.GetNextEntry();
  456.             while (zipEntryFromZippedFile != null)
  457.             {
  458.                 if (zipEntryFromZippedFile.IsFile)
  459.                 {
  460.                     FileInfo fInfo = new FileInfo(string.Format(zipedFolder + "\\{0}", zipEntryFromZippedFile.Name));
  461.                     if (!fInfo.Directory.Exists) fInfo.Directory.Create();
  462.  
  463.                     FileStream file = fInfo.Create();
  464.                     byte[] bufferFromZip = new byte[zipInputStream.Length];
  465.                     zipInputStream.Read(bufferFromZip, , bufferFromZip.Length);
  466.                     file.Write(bufferFromZip, , bufferFromZip.Length);
  467.                     file.Close();
  468.                 }
  469.                 zipEntryFromZippedFile = zipInputStream.GetNextEntry();
  470.             }
  471.             zipInputStream.Close();
  472.             return true;
  473.         }
  474.  
  475.         #endregion
  476.     }
  477. }

压缩文件夹，是否包含父文件夹，调用：

  1.  public static bool ZipDirectory(string folderToZip, string zipedFile, Boolean IncludeParent)
  2.  
  3. 解压缩功能我也将原方法注释了，重新找了一个方法，因为原方法在将.xml文件解压出来的时候，会在末尾加入一堆NULNULNULNUL.......，大家可以自己去尝试下。

2017.8.12补充：

解压自己的打包的压缩包报错：EOF in header.......
准备换winrar.

  1.  

C#压缩文件夹至zip，不包含所选文件夹【转+修改】的更多相关文章

  1. PHP 多文件打包下载 zip

    <?php $zipname = './photo.zip'; //服务器根目录下有文件夹public,其中包含三个文件img1.jpg, img2.jpg, img3.jpg,将这三个文件打包 ...

  2. 如何使用Beyond Compare 对比差异文件【制作Patch（补丁包）文件】

    场景:研发部的代码从SVN变更至GIt,通过Jenkins每天自动生成程序包. 如需要获取单独的程序包更新,而不是整个程序包覆盖更新,这时候就需要用到Beyond Compare 对比工具 操作步骤1 ...

  3. 命令行方式调用winrar对文件夹进行zip压缩示例代码

    调用winRAR进行压缩 using System; using System.Collections.Generic; using System.Linq; using System.Text; u ...

  4. Python压缩指定文件及文件夹为zip

    Python压缩指定的文件及文件夹为.zip 代码: def zipDir(dirpath,outFullName): """ 压缩指定文件夹 :param dirpat ...

  5. Java实现文件压缩与解压[zip格式,gzip格式]

    Java实现ZIP的解压与压缩功能基本都是使用了Java的多肽和递归技术,可以对单个文件和任意级联文件夹进行压缩和解压,对于一些初学者来说是个很不错的实例. zip扮演着归档和压缩两个角色:gzip并 ...

  6. Linux命令（十六） 压缩或解压缩文件和目录 zip unzip

    目录 1.命令简介 2.常用参数介绍 3.实例 4.直达底部 命令简介 zip 是 Linux 系统下广泛使用的压缩程序,文件压缩后扩展名为 ".zip". zip 命令用来将文件 ...

  7. linux下压缩成zip文件解压zip文件

    linux  zip命令的基本用法是: zip [参数] [打包后的文件名] [打包的目录路径] linux  zip命令参数列表: -a     将文件转成ASCII模式 -F     尝试修复损坏 ...

  8. java笔试题: ——将e:/source文件夹下的文件打个zip包后拷贝到f:/文件夹下面

    将e:/source文件夹下的文件打个zip包后拷贝到f:/文件夹下面 import java.io.*; import java.util.zip.ZipEntry; import java.uti ...

  9. gulp插件实现压缩一个文件夹下不同目录下的js文件（支持es6）

    gulp-uglify:压缩js大小,只支持es5 安装: cnpm: cnpm i gulp-uglify -D yarn: yarn add gulp-uglify -D 使用: 代码实现1:压缩 ...

随机推荐

  1. jacoco+maven生成单元测试覆盖率报告

    参考:https://www.petrikainulainen.net/programming/maven/creating-code-coverage-reports-for-unit-and-in ...

  2. iOS单例设计模式具体解说(单例设计模式不断完好的过程)

    在iOS中有非常多的设计模式,有一本书<Elements of Reusable Object-Oriented Software>(中文名字为<设计模式>)讲述了23种软件设 ...

  3. JsonArray和JsonObject的使用

    import net.sf.json.JSONArray; import net.sf.json.JSONObject; public class JsonTest { public static v ...

  4. Guake Terminal ── linux下完美帅气的终端

    虽说如今非常多Linux发行版.比方Ubuntu,已经基本上能够採用GUI来完毕绝大部分一般性的任务. 可是,终端程序对于linux用户来说仍是不可缺少的. Gnome自带的gnome-termina ...

  5. please get a license from www.texturepacker.com

    我们在使用texturepacker创建资源后,在使用资源时出现下述问题:please get a license from www.texturepacker.com 如图: 这个是由于我们的版本号 ...

  6. 服务器无法处理请求。 ---> 未将对象引用设置到对象的实例

    服务器无法处理请求. ---> 未将对象引用设置到对象的实例. 简短说下我遇到的问题.webservice部署到服务器上后,访问方法报上面的错误,最终原因为改方法需要操作文件夹,加上了相应的权限 ...

  7. 用js采集网页数据并插入数据库最快的方法

    今天教大家一个快速采集网站数据的方法,因为太晚了,直接上例子,这里以采集易车网的产品数据为例. 思路:利用js获取网页数据并生成sql命令,执行sql命令把采集的数据插入数据库. 1.用谷歌浏览器或者 ...

  8. ios24--改变button的文字和图片

    // // ViewController.m // 09-UIButton内部子控件的调整 // // Created by xiaomage on 15/12/30. // Copyright © ...

  9. ngnix 详解

    4 Nginx的rpm软件包安装 4.1 安装包在位置 D:\讲课内容--\新巴巴运动网\nginx高并发解决\nginx安装包 4.2 此种安装方式不用安装gcc等编译工具 4.3 安装命令如下 r ...

  10. 如何调试Node.js

    Debugging Node.js with Chrome DevTools https://nodejs.org/en/docs/guides/debugging-getting-started/ ...