SharpZLib 使用方法

在做项目的时候需要将文件进行压缩和解压缩，于是就从http://www.icsharpcode.net下载了关于压缩和解压缩的源码，但是下载下来后，面对这么多的代码，一时不知如何下手。只好耐下心来，慢慢的研究，总算找到了门路。针对自己的需要改写了文件压缩和解压缩的两个类，分别为 ZipClass和UnZipClass。其中碰到了不少困难，就决定写出来压缩和解压的程序后，一定把源码贴出来共享，让首次接触压缩和解压缩的朋友可以少走些弯路。下面就来解释如何C#利用sharpziplib进行文件的压缩和解压缩。

首先需要在项目里C#利用sharpziplib.dll。然后修改其中的关于压缩和解压缩的类。实现源码如下：

 

文件压缩

/// <summary>   
/// 压缩文件    
/// </summary>   
   
using System;    
using System.IO;    
   
using ICSharpCode.SharpZipLib.Checksums;    
using ICSharpCode.SharpZipLib.Zip;    
using ICSharpCode.SharpZipLib.GZip;    
   
namespace Compression    
{    
 public class ZipClass    
 {    
    
     public void ZipFile(string FileToZip, string ZipedFile ,  
     int CompressionLevel, int BlockSize)    
     {    
         //如果文件没有找到，则报错    
         if (! System.IO.File.Exists(FileToZip))    
         {    
             throw new System.IO.FileNotFoundException  
             ("The specified file " + FileToZip + " could not be found. Zipping aborderd");    
         }    
            
         system.io.filestream StreamToZip = new System.IO.FileStream  
         (FileToZip,System.IO.FileMode.Open , System.IO.FileAccess.Read);    
         System.IO.FileStream ZipFile = System.IO.File.Create(ZipedFile);    
         ZipOutputStream ZipStream = new ZipOutputStream(ZipFile);    
         ZipEntry ZipEntry = new ZipEntry("ZippedFile");    
         ZipStream.PutNextEntry(ZipEntry);    
         ZipStream.SetLevel(CompressionLevel);    
         byte[] buffer = new byte[BlockSize];    
         System.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;    
             }    
         }    
         catch(System.Exception ex)    
         {    
            throw ex;    
         }    
         ZipStream.Finish();    
         ZipStream.Close();    
         StreamToZip.Close();    
     }    
        
     public void ZipFileMain(string[] args)    
     {    
         string[] filenames = Directory.GetFiles(args[0]);    
            
         crc32 crc = new Crc32();    
         ZipOutputStream s = new ZipOutputStream(File.Create(args[1]));    
            
         s.setlevel(6); // 0 - store only to 9 - means best compression    
            
         foreach (string file in filenames)    
         {    
             //打开压缩文件    
             FileStream fs = File.OpenRead(file);    
                
             byte[] buffer = new byte[fs.Length];    
             fs.Read(buffer, 0, buffer.Length);    
             ZipEntry entry = new ZipEntry(file);    
                
             entry.datetime = DateTime.Now;    
                
             // set Size and the crc, because the information    
             // about the size and crc should be stored in the header    
             // if it is not set it is automatically written in the footer.    
             // (in this case size == crc == -1 in the header)    
             // Some ZIP programs have problems with zip files that don't store    
             // the size and crc in the header.    
             entry.Size = fs.Length;    
             fs.Close();    
                
             crc.reset();    
             crc.Update(buffer);    
                
             entry.crc = crc.Value;    
                
             s.putnextentry(entry);    
                
             s.write(buffer, 0, buffer.Length);    
            
         }    
            
         s.finish();    
         s.Close();    
     }    
 }    
}    

文件解压缩

public class UnZipClass
    {
        /// <summary> 
        /// 解压文件 
        /// </summary> 
        /// <param name="args">包含要解压的文件名和要解压到的目录名数组</param> 
        public void UnZip(string[] args)
        {
            ZipInputStream s = new ZipInputStream(File.OpenRead(args[0]));
            try
            {
                string directoryName = Path.GetDirectoryName(args[1]);

                ZipEntry theEntry;
                while ((theEntry = s.GetNextEntry()) != null)
                {                    
                    
                    string fileName = Path.GetFileName(theEntry.Name);
                    string path = directoryName +"\\" +Path.GetDirectoryName(theEntry.Name);
                    //生成解压目录 
                    if (!Directory.Exists(path))
                    {
                        Directory.CreateDirectory(path);
                    }
                    if (fileName != String.Empty)
                    {
                        //解压文件到指定的目录 
                        FileStream streamWriter = File.Create(path +"\\"+ 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;
                            }
                        }

                        streamWriter.Close();
                    }
                }
                s.Close();
            }
            catch (Exception eu)
            {
                throw eu;
            }
            finally
            {
                s.Close();
            }

        }//end UnZip 

        public static bool UnZipFile(string file, string dir)
        {
            try
            {
                if (!Directory.Exists(dir))
                    Directory.CreateDirectory(dir);
                string fileFullName = Path.Combine(dir, file);
                ZipInputStream s = new ZipInputStream(File.OpenRead(fileFullName));

                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(Path.Combine(dir, directoryName));

                    if (fileName != String.Empty)
                    {
                        FileStream streamWriter = File.Create(Path.Combine(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;
            }
        }

    }

二进制字节流压缩解压缩

using System;  
  
using ICSharpCode.SharpZipLib;  
using ICSharpCode.SharpZipLib.Zip.Compression;  
using System.IO;  
  
namespace Lucene.Net.Index.Compression  
{  
    public class SharpZipLibAdapter   
    {  
        public byte[] Compress(byte[] input)  
        {  
            // Create the compressor with highest level of compression  
            Deflater compressor = new Deflater();  
            compressor.SetLevel(Deflater.BEST_COMPRESSION);  
  
            // Give the compressor the data to compress  
            compressor.SetInput(input);  
            compressor.Finish();  
  
            /* 
             * Create an expandable byte array to hold the compressed data. 
             * You cannot use an array that's the same size as the orginal because 
             * there is no guarantee that the compressed data will be smaller than 
             * the uncompressed data. 
             */  
            MemoryStream bos = new MemoryStream(input.Length);  
  
            // Compress the data  
            byte[] buf = new byte[1024];  
            while (!compressor.IsFinished)  
            {  
                int count = compressor.Deflate(buf);  
                bos.Write(buf, 0, count);  
            }  
  
            // Get the compressed data  
            return bos.ToArray();  
        }  
  
        public byte[] Uncompress(byte[] input)  
        {  
            Inflater decompressor = new Inflater();  
            decompressor.SetInput(input);  
  
            // Create an expandable byte array to hold the decompressed data  
            MemoryStream bos = new MemoryStream(input.Length);  
  
            // Decompress the data  
            byte[] buf = new byte[1024];  
            while (!decompressor.IsFinished)  
            {  
                int count = decompressor.Inflate(buf);  
                bos.Write(buf, 0, count);  
            }  
  
            // Get the decompressed data  
            return bos.ToArray();  
        }  
    }  
}