最好的.NET開源免費ZIP庫DotNetZip（.NET組件介紹之三）

時間  2019-11-13
標籤 最好 開源 免費 zip dotnetzip 組件 介紹 之三 欄目 數據壓縮 简体版
原文   原文鏈接

   在項目開發中，除了對數據的展現更多的就是對文件的相關操做，例如文件的建立和刪除，以及文件的壓縮和解壓。文件壓縮的好處有不少，主要就是在文件傳輸的方面，文件壓縮的好處就不須要贅述，由於不管是開發者，仍是使用者對於文件壓縮的好處都是深有體會。至於文件壓縮的原理，在個人另外一篇博客中有簡單的介紹，在這裏就再也不作介紹，須要瞭解的能夠查看。html

   .NET在System.IO.Compression命名空間中提供了GZip、Defalate兩種壓縮算法。今天我要介紹的一種壓縮組件是DotNetZip組件。算法

一.DotNetZip組件概述：

   在DotNetZip的自我介紹中號稱是」DotNetZip是.NET最好的開源ZIP庫「，至因而不是最好的壓縮組件，在這裏就不作評價，畢竟每一個使用者的心態和工做環境不一樣，項目對組件的需求也不一樣，在選擇組件的時候，就須要開發者本身衡量了。估計不少人尚未看到這裏就開始在鍵盤上敲字吐槽了，標題是我借用官方對外的宣傳口號，不用太在乎這些細節。shell

   DotNetZip - Zip和解壓縮在C＃，VB，任何.NET語言均可使用。DotNetZip是一個FAST，免費類庫和用於操縱zip文件的工具集。 使用VB，C＃或任何.NET語言輕鬆建立，解壓縮或更新zip文件。DotNetZip在具備完整.NET Framework的PC上運行，而且還在使用.NET Compact Framework的移動設備上運行。在VB，C＃或任何.NET語言或任何腳本環境中建立和讀取zip文件。數組

  DotNetZip組件的使用環境，畢竟軟件的使用環境是每個開發者都須要考慮的，這個世界沒有絕對的好事，固然也沒有絕對的壞事。接下來看一下其實用環境的說明吧：瀏覽器

　　1.一個動態建立zip文件的Silverlight應用程序。dom

　　2.一個ASP.NET應用程序，動態建立ZIP文件並容許瀏覽器下載它們。ide

　　3.一個Windows服務，按期地爲了備份和歸檔目的上拉一個目錄。工具

　　4.修改現有歸檔的WPF程序 - 重命名條目，從歸檔中刪除條目或向歸檔中添加新條目。post

　　5.一個Windows窗體應用程序，用於爲歸檔內容的隱私建立AES加密的zip存檔。this

　　6.解壓縮或拉鍊的SSIS腳本。

　　7.PowerShell或VBScript中的一個管理腳本，用於執行備份和歸檔。

　　8.WCF服務，接收做爲附件的zip文件，並動態地將zip解壓縮到流以進行分析。

　　9.一個老式的ASP（VBScript）應用程序，經過COM接口爲DotNetZIp生成一個ZIP文件。

　　10.讀取或更新ODS文件的Windows Forms應用程序。

　　11.從流內容建立zip文件，保存到流，提取到流，從流讀取。

　　12.建立自解壓檔案。

   DotNetZip是一個100％的託管代碼庫，可用於任何.NET應用程序 - 控制檯，Winforms，WPF，ASP.NET，Sharepoint，Web服務應用程序等。 新的v1.9.1.6：Silverlight。 它還能夠從腳本環境或具備COM功能的環境（如Powershell腳本，VBScript，VBA，VB6，PHP，Perl，Javascript等）中使用。 不管使用什麼環境，DotNetZip生成的zip文件可與Windows資源管理器以及Java應用程序，在Linux上運行的應用程序徹底互操做。

    該組件設計簡單，易於使用。 DotNetZip打包爲一個單一的DLL，大小約400k。 它沒有第三方依賴。 它是中等信任，所以能夠在大多數託管商使用。 經過引用DLL來獲取壓縮。 該庫支持zip密碼，Unicode，ZIP64，流輸入和輸出，AES加密，多個壓縮級別，自解壓縮存檔，跨區存檔等。

   以上的一些描述來自與官網，就再也不吹捧這個組件了，在這裏須要說明的是在組件的選擇和使用上，主要取決與項目的實際狀況。詳情見：http://dotnetzip.codeplex.com/

二.DotNetZip相關核心類和方法解析：

    因爲下載的是DLL文件，仍是採用.NET Reflector對DLL文件進行反編譯，以此查看源代碼。一下主要介紹一些類和方法，沒有徹底介紹，首先是因爲篇幅所限，實際上是徹底沒有必要，由於對於開發者而言，沒有必要所有了解這些類，在實際的開發中，能夠根據API進行對應的方法調用，這些技能應該是一個開發人員應該具有的。

   1.ZipFile類的AddEntry()、Save()和IsZipFile()方法：

public ZipEntry AddEntry(string entryName, WriteDelegate writer)
{
    ZipEntry ze = ZipEntry.CreateForWriter(entryName, writer);
    if (this.Verbose)
    {
        this.StatusMessageTextWriter.WriteLine("adding {0}...", entryName);
    }
    return this._InternalAddEntry(ze);
}

 
public void Save()
{
    try
    {
        bool flag = false;
        this._saveOperationCanceled = false;
        this._numberOfSegmentsForMostRecentSave = 0;
        this.OnSaveStarted();
        if (this.WriteStream == null)
        {
            throw new BadStateException("You haven't specified where to save the zip.");
        }
        if (((this._name != null) && this._name.EndsWith(".exe")) && !this._SavingSfx)
        {
            throw new BadStateException("You specified an EXE for a plain zip file.");
        }
        if (!this._contentsChanged)
        {
            this.OnSaveCompleted();
            if (this.Verbose)
            {
                this.StatusMessageTextWriter.WriteLine("No save is necessary....");
            }
        }
        else
        {
            this.Reset(true);
            if (this.Verbose)
            {
                this.StatusMessageTextWriter.WriteLine("saving....");
            }
            if ((this._entries.Count >= 0xffff) && (this._zip64 == Zip64Option.Default))
            {
                throw new ZipException("The number of entries is 65535 or greater. Consider setting the UseZip64WhenSaving property on the ZipFile instance.");
            }
            int current = 0;
            ICollection<ZipEntry> entries = this.SortEntriesBeforeSaving ? this.EntriesSorted : this.Entries;
            foreach (ZipEntry entry in entries)
            {
                this.OnSaveEntry(current, entry, true);
                entry.Write(this.WriteStream);
                if (this._saveOperationCanceled)
                {
                    break;
                }
                current++;
                this.OnSaveEntry(current, entry, false);
                if (this._saveOperationCanceled)
                {
                    break;
                }
                if (entry.IncludedInMostRecentSave)
                {
                    flag |= entry.OutputUsedZip64.Value;
                }
            }
            if (!this._saveOperationCanceled)
            {
                ZipSegmentedStream writeStream = this.WriteStream as ZipSegmentedStream;
                this._numberOfSegmentsForMostRecentSave = (writeStream != null) ? writeStream.CurrentSegment : 1;
                bool flag2 = ZipOutput.WriteCentralDirectoryStructure(this.WriteStream, entries, this._numberOfSegmentsForMostRecentSave, this._zip64, this.Comment, new ZipContainer(this));
                this.OnSaveEvent(ZipProgressEventType.Saving_AfterSaveTempArchive);
                this._hasBeenSaved = true;
                this._contentsChanged = false;
                flag |= flag2;
                this._OutputUsesZip64 = new bool?(flag);
                if ((this._name != null) && ((this._temporaryFileName != null) || (writeStream != null)))
                {
                    this.WriteStream.Dispose();
                    if (this._saveOperationCanceled)
                    {
                        return;
                    }
                    if (this._fileAlreadyExists && (this._readstream != null))
                    {
                        this._readstream.Close();
                        this._readstream = null;
                        foreach (ZipEntry entry2 in entries)
                        {
                            ZipSegmentedStream stream2 = entry2._archiveStream as ZipSegmentedStream;
                            if (stream2 != null)
                            {
                                stream2.Dispose();
                            }
                            entry2._archiveStream = null;
                        }
                    }
                    string path = null;
                    if (File.Exists(this._name))
                    {
                        path = this._name + "." + Path.GetRandomFileName();
                        if (File.Exists(path))
                        {
                            this.DeleteFileWithRetry(path);
                        }
                        File.Move(this._name, path);
                    }
                    this.OnSaveEvent(ZipProgressEventType.Saving_BeforeRenameTempArchive);
                    File.Move((writeStream != null) ? writeStream.CurrentTempName : this._temporaryFileName, this._name);
                    this.OnSaveEvent(ZipProgressEventType.Saving_AfterRenameTempArchive);
                    if (path != null)
                    {
                        try
                        {
                            if (File.Exists(path))
                            {
                                File.Delete(path);
                            }
                        }
                        catch
                        {
                        }
                    }
                    this._fileAlreadyExists = true;
                }
                NotifyEntriesSaveComplete(entries);
                this.OnSaveCompleted();
                this._JustSaved = true;
            }
        }
    }
    finally
    {
        this.CleanupAfterSaveOperation();
    }
}
public static bool IsZipFile(Stream stream, bool testExtract)
{
    if (stream == null)
    {
        throw new ArgumentNullException("stream");
    }
    bool flag = false;
    try
    {
        if (!stream.CanRead)
        {
            return false;
        }
        Stream @null = Stream.Null;
        using (ZipFile file = Read(stream, null, null, null))
        {
            if (testExtract)
            {
                foreach (ZipEntry entry in file)
                {
                    if (!entry.IsDirectory)
                    {
                        entry.Extract(@null);
                    }
                }
            }
        }
        flag = true;
    }
    catch (IOException)
    {
    }
    catch (ZipException)
    {
    }
    return flag;
}

 2.Read()讀取數據流：

private static ZipFile Read(Stream zipStream, TextWriter statusMessageWriter, Encoding encoding, EventHandler<ReadProgressEventArgs> readProgress)
{
    if (zipStream == null)
    {
        throw new ArgumentNullException("zipStream");
    }
    ZipFile zf = new ZipFile {
        _StatusMessageTextWriter = statusMessageWriter,
        _alternateEncoding = encoding ?? DefaultEncoding,
        _alternateEncodingUsage = ZipOption.Always
    };
    if (readProgress != null)
    {
        zf.ReadProgress += readProgress;
    }
    zf._readstream = (zipStream.Position == 0L) ? zipStream : new OffsetStream(zipStream);
    zf._ReadStreamIsOurs = false;
    if (zf.Verbose)
    {
        zf._StatusMessageTextWriter.WriteLine("reading from stream...");
    }
    ReadIntoInstance(zf);
    return zf;
}

   以上是對ZipFile類的一些方法的解析，提供了該組件的一些方法的源碼，至於源碼的解讀上難度不是很大，至於該組件的API，能夠在下載DLL文件後，能夠直接查看相應的方法和屬性，在這裏就不作詳細的介紹。

三.DotNetZip組件使用實例：

   以上是對該組件的一些解析，接下來咱們看看實例：

1.壓縮ZIP文件：

        /// <summary>
        /// 壓縮ZIP文件
        /// 支持多文件和多目錄，或是多文件和多目錄一塊兒壓縮
        /// </summary>
        /// <param name="list">待壓縮的文件或目錄集合</param>
        /// <param name="strZipName">壓縮後的文件名</param>
        /// <param name="isDirStruct">是否按目錄結構壓縮</param>
        /// <returns>成功：true/失敗：false</returns>
        public static bool CompressMulti(List<string> list, string strZipName, bool isDirStruct)
        {
            if (list == null)
            {
                throw new ArgumentNullException("list");
            }
            if (string.IsNullOrEmpty(strZipName))
            {
                throw new ArgumentNullException(strZipName);
            }
            try
            {
                //設置編碼，解決壓縮文件時中文亂碼
                using (var zip = new ZipFile(Encoding.Default))
                {
                    foreach (var path in list)
                    {
                        //取目錄名稱
                        var fileName = Path.GetFileName(path);
                        //若是是目錄
                        if (Directory.Exists(path))
                        {
                            //按目錄結構壓縮
                            if (isDirStruct)
                            {
                                zip.AddDirectory(path, fileName);
                            }
                            else
                            {
                                //目錄下的文件都壓縮到Zip的根目錄
                                zip.AddDirectory(path);
                            }
                        }
                        if (File.Exists(path))
                        {
                            zip.AddFile(path);
                        }
                    }
                    //壓縮
                    zip.Save(strZipName);
                    return true;
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

2.解壓ZIP文件：

        /// <summary>
        /// 解壓ZIP文件
        /// </summary>
        /// <param name="strZipPath">待解壓的ZIP文件</param>
        /// <param name="strUnZipPath">解壓的目錄</param>
        /// <param name="overWrite">是否覆蓋</param>
        /// <returns>成功：true/失敗：false</returns>
        public static bool Decompression(string strZipPath, string strUnZipPath, bool overWrite)
        {
            if (string.IsNullOrEmpty(strZipPath))
            {
                throw new ArgumentNullException(strZipPath);
            }
            if (string.IsNullOrEmpty(strUnZipPath))
            {
                throw new ArgumentNullException(strUnZipPath);
            }
            try
            {
                var options = new ReadOptions
                {
                    Encoding = Encoding.Default
                };
                //設置編碼，解決解壓文件時中文亂碼
                using (var zip = ZipFile.Read(strZipPath, options))
                {
                    foreach (var entry in zip)
                    {
                        if (string.IsNullOrEmpty(strUnZipPath))
                        {
                            strUnZipPath = strZipPath.Split('.').First();
                        }
                        entry.Extract(strUnZipPath,overWrite
                                ? ExtractExistingFileAction.OverwriteSilently
                                : ExtractExistingFileAction.DoNotOverwrite);
                    }
                    return true;
                }
            }
            catch (Exception ex)
            {
               throw new Exception(ex.Message);
            }
        }

3.獲得指定的輸入流的ZIP壓縮流對象：

        /// <summary>
        /// 獲得指定的輸入流的ZIP壓縮流對象
        /// </summary>
        /// <param name="sourceStream">源數據流</param>
        /// <param name="entryName">實體名稱</param>
        /// <returns></returns>
        public static Stream ZipCompress(Stream sourceStream, string entryName = "zip")
        {
            if (sourceStream == null)
            {
                throw new ArgumentNullException("sourceStream");
            }
            var compressedStream = new MemoryStream();      
            long sourceOldPosition = 0;
            try
            {
                sourceOldPosition = sourceStream.Position;
                sourceStream.Position = 0;
                using (var zip = new ZipFile())
                {
                    zip.AddEntry(entryName, sourceStream);
                    zip.Save(compressedStream);
                    compressedStream.Position = 0;
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                try
                {
                    sourceStream.Position = sourceOldPosition;
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
            }
            return compressedStream;
        }

4.獲得指定的字節數組的ZIP解壓流對象：

        /// <summary>
        /// 獲得指定的字節數組的ZIP解壓流對象
        /// 當前方法僅適用於只有一個壓縮文件的壓縮包，即方法內只取壓縮包中的第一個壓縮文件
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static Stream ZipDecompress(byte[] data)
        {
            Stream decompressedStream = new MemoryStream();
            if (data == null) return decompressedStream;
            try
            {
                var dataStream = new MemoryStream(data);
                using (var zip = ZipFile.Read(dataStream))
                {
                    if (zip.Entries.Count > 0)
                    {
                        zip.Entries.First().Extract(decompressedStream);
                        // Extract方法中會操做ms，後續使用時必須先將Stream位置歸零，不然會致使後續讀取不到任何數據
                        // 返回該Stream對象以前進行一次位置歸零動做
                        decompressedStream.Position = 0;
                    }
                }
            }
            catch(Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return decompressedStream;
        }

四.總結：

   以上是對DotNetZip組件的一些解析和方法實例，至於這款組件是否是最好的.NET壓縮組件，這個就不作評價。我的在選擇組件的時候，首先考慮的是開源，其次是免費，最後再考慮效率和實用性，畢竟在國內的一些狀況是全部開發者都清楚的（不提國外是因爲我不知道國外的狀況）。客戶須要下降成本，而且組件要能夠進行定製。不過我的認爲收費應該是一種趨勢，畢竟全部的產品都是須要人員進行維護和開發。以上的博文中有不足之處，還望多多指正。

 

.NET組件介紹系列：

    一款開源免費的.NET文檔操做組件DocX（.NET組件介紹之一）http://www.cnblogs.com/pengze0902/p/6122311.html

    高效而穩定的企業級.NET Office 組件Spire（.NET組件介紹之二）http://www.cnblogs.com/pengze0902/p/6125570.html

    最好的.NET開源免費ZIP庫DotNetZip（.NET組件介紹之三）http://www.cnblogs.com/pengze0902/p/6124659.html

    免費開源的DotNet二維碼操做組件ThoughtWorks.QRCode（.NET組件介紹之四）http://www.cnblogs.com/pengze0902/p/6134506.html

    免費開源的DotNet任務調度組件Quartz.NET（.NET組件介紹之五）http://www.cnblogs.com/pengze0902/p/6128558.html

    免費高效實用的Excel操做組件NPOI（.NET組件介紹之六）http://www.cnblogs.com/pengze0902/p/6150070.html

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程