C#ZipHelper帮助类，实现压缩、解压缩的功能 - 苏飞论坛

上传

点击文件名下载附件
主要功能如下所示
1.压缩
2.解压缩
3.指定目录
4.递归压缩文件夹
源码预览
[code=csharp]/// <summary>
/// 类说明：SharpZip,ClassZip,ZipHelper
/// 编码人：苏飞
/// 联系方式：361983679
/// 更新网站：http://www.sufeinet.com/thread-655-1-1.html
/// </summary>
using System;
using System.IO;
using System.Diagnostics;
using Microsoft.Win32;

using ICSharpCode.SharpZipLib.Checksums;
using ICSharpCode.SharpZipLib.Zip;

///压缩、解压缩类
namespace DotNet.Utilities
{
public class SharpZip
{
      public SharpZip()
      { }

      /// <summary>
      /// 压缩
      /// </summary>
      /// <param name="filename"> 压缩后的文件名(包含物理路径)</param>
      /// <param name="directory">待压缩的文件夹(包含物理路径)</param>
      public static void PackFiles(string filename, string directory)
      {
         try
         {
            FastZip fz = new FastZip();
            fz.CreateEmptyDirectories = true;
            fz.CreateZip(filename, directory, true, "");
            fz = null;
         }
         catch (Exception)
         {
            throw;
         }
      }

      /// <summary>
      /// 解压缩
      /// </summary>
      /// <param name="file">待解压文件名(包含物理路径)</param>
      /// <param name="dir"> 解压到哪个目录中(包含物理路径)</param>
      public static bool UnpackFiles(string file, string dir)
      {
         try
         {
            if (!Directory.Exists(dir))
            {
                  Directory.CreateDirectory(dir);
            }
            ZipInputStream s = new ZipInputStream(File.OpenRead(file));
            ZipEntry theEntry;
            while ((theEntry = s.GetNextEntry()) != null)
            {
                  string directoryName = Path.GetDirectoryName(theEntry.Name);
                  string fileName = Path.GetFileName(theEntry.Name);
                  if (directoryName != String.Empty)
                  {
                     Directory.CreateDirectory(dir + directoryName);
                  }
                  if (fileName != String.Empty)
                  {
                     FileStream streamWriter = File.Create(dir + theEntry.Name);
                     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;
                        }
                     }
                     streamWriter.Close();
                  }
            }
            s.Close();
            return true;
         }
         catch (Exception)
         {
            throw;
         }
      }
}

public class ClassZip
{
      #region 私有方法
      /// <summary>
      /// 递归压缩文件夹方法
      /// </summary>
      private static 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);
                  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>
      private static bool ZipFileDictory(string FolderToZip, string ZipedFile, int level)
      {
         bool res;
         if (!Directory.Exists(FolderToZip))
         {
            return false;
         }
         ZipOutputStream s = new ZipOutputStream(File.Create(ZipedFile));
         s.SetLevel(level);
         res = ZipFileDictory(FolderToZip, s, "");
         s.Finish();
         s.Close();
         return res;
      }

      /// <summary>
      /// 压缩文件
      /// </summary>
      /// <param name="FileToZip">要进行压缩的文件名</param>
      /// <param name="ZipedFile">压缩后生成的压缩文件名</param>
      private static bool ZipFile(string FileToZip, string ZipedFile, int level)
      {
         if (!File.Exists(FileToZip))
         {
            throw new System.IO.FileNotFoundException("指定要压缩的文件: " + FileToZip + " 不存在!");
         }
         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(level);

            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;
      }
      #endregion

      /// <summary>
      /// 压缩
      /// </summary>
      /// <param name="FileToZip">待压缩的文件目录</param>
      /// <param name="ZipedFile">生成的目标文件</param>
      /// <param name="level">6</param>
      public static bool Zip(String FileToZip, String ZipedFile, int level)
      {
         if (Directory.Exists(FileToZip))
         {
            return ZipFileDictory(FileToZip, ZipedFile, level);
         }
         else if (File.Exists(FileToZip))
         {
            return ZipFile(FileToZip, ZipedFile, level);
         }
         else
         {
            return false;
         }
      }

      /// <summary>
      /// 解压
      /// </summary>
      /// <param name="FileToUpZip">待解压的文件</param>
      /// <param name="ZipedFolder">解压目标存放目录</param>
      public static void UnZip(string FileToUpZip, string ZipedFolder)
      {
         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));
            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);
         }
      }
}

public class ZipHelper
{
      #region 私有变量
      String the_rar;
      RegistryKey the_Reg;
      Object the_Obj;
      String the_Info;
      ProcessStartInfo the_StartInfo;
      Process the_Process;
      #endregion

      /// <summary>
      /// 压缩
      /// </summary>
      /// <param name="zipname">要解压的文件名</param>
      /// <param name="zippath">要压缩的文件目录</param>
      /// <param name="dirpath">初始目录</param>
      public void EnZip(string zipname, string zippath, string dirpath)
      {
         try
         {
            the_Reg = Registry.ClassesRoot.OpenSubKey(@"Applications\WinRAR.exe\Shell\Open\Command");
            the_Obj = the_Reg.GetValue("");
            the_rar = the_Obj.ToString();
            the_Reg.Close();
            the_rar = the_rar.Substring(1, the_rar.Length - 7);
            the_Info = " a " + zipname + "  " + zippath;
            the_StartInfo = new ProcessStartInfo();
            the_StartInfo.FileName = the_rar;
            the_StartInfo.Arguments = the_Info;
            the_StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            the_StartInfo.WorkingDirectory = dirpath;
            the_Process = new Process();
            the_Process.StartInfo = the_StartInfo;
            the_Process.Start();
         }
         catch (Exception ex)
         {
            throw new Exception(ex.Message);
         }
      }

      /// <summary>
      /// 解压缩
      /// </summary>
      /// <param name="zipname">要解压的文件名</param>
      /// <param name="zippath">要解压的文件路径</param>
      public void DeZip(string zipname, string zippath)
      {
         try
         {
            the_Reg = Registry.ClassesRoot.OpenSubKey(@"Applications\WinRar.exe\Shell\Open\Command");
            the_Obj = the_Reg.GetValue("");
            the_rar = the_Obj.ToString();
            the_Reg.Close();
            the_rar = the_rar.Substring(1, the_rar.Length - 7);
            the_Info = " X " + zipname + " " + zippath;
            the_StartInfo = new ProcessStartInfo();
            the_StartInfo.FileName = the_rar;
            the_StartInfo.Arguments = the_Info;
            the_StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            the_Process = new Process();
            the_Process.StartInfo = the_StartInfo;
            the_Process.Start();
         }
         catch (Exception ex)
         {
            throw new Exception(ex.Message);
         }
      }
}
}[/code]
使用方法如下
[code=csharp]  private void Form1_Load(object sender, EventArgs e)
      {
         //将c:\\123.zip解压缩存放到c:\\zip目录下
         ClassZip.UnZip("c:\\123.zip", "c:\\zip");

         //将c:\\123.txt压缩存放到c:\\zip目录下
         ClassZip.Zip("c:\\123.txt", "c:\\zip", 6);

         //将c:\\123.txt压缩存放到c:\\zip目录下
         ZipHelper zh = new ZipHelper();
         zh.DeZip("c:\\123.zip", "c:\\zip");
         zh.EnZip("c:\\123.txt", "c:\\zip", "c:\\zip");

      }[/code]
大家自己做个测试吧，
其实这个功能还是很常用的，当我们上传文件时进行一次压缩再上传是非常省流量的一件事情

[groupid=74]sufeinet总群[/groupid]

作者: inghot 时间: 2013-8-17 10:08
嗯，以前也改过一个，经常会用到。

作者: 站长苏飞 时间: 2013-8-17 10:34

inghot 发表于 2013-8-17 10:08
嗯，以前也改过一个，经常会用到。

这个在上传下载时很常用，而且是非常建议使用压缩的方法，省流量

作者: changlei 时间: 2013-11-6 10:11
苏总这个类支持 tar.gz后缀的吗？

作者: 站长苏飞 时间: 2013-11-6 10:24

changlei 发表于 2013-11-6 10:11
苏总这个类支持 tar.gz后缀的吗？

你试试看，呵呵

作者: atgu2je 时间: 2014-3-22 13:25
膜拜中……

作者: wsmwzd 时间: 2015-3-24 00:35
淡定，淡定，毒贩夫妇淡定……

作者: 937658938 时间: 2016-6-30 10:08
问题来了：当解压文件的时候如果里面有一个没有后缀的文件那么这个代码会不会出问题（我自己的报错了）

作者: MeeSii 时间: 2016-11-25 06:16
中文乱码的解决方案：

下载 SharpZipLib_0855_SourceSamples.zip

解压缩，然后在src文件夹中双击ICSharpCode.SharpZLib.csproj打开项目。在ZipEntryFactory.cs文件的223行(MakeFileEntry函数的第二行)，修改

result.IsUnicodeText = true;

欢迎光临苏飞论坛 (http://www.sufeinet.com/)