正文

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

︶ㄣSDDLL学院 メ
SDDLL学院V管理员 / 阅读
0708
本文介绍C#实现压缩与解压缩帮助类ZipHelper，主要是通过ICSharpCode.SharpZipLib 类库实现的。

本文介绍C#实现压缩与解压缩帮助类ZipHelper，主要是通过ICSharpCode.SharpZipLib 类库实现的。

关于本文档的说明

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

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

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

1.基本介绍

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

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

2.实际项目

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

2.1 压缩单个文件

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

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

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 直接解压，无需密码

?
1
public void UnZip(string zipFilePath, string unZipDir)

3.演示图　

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

3.ZipHelper源码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
//-------------------------------------------------------------------------------------
// 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;
    }
  }
}

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