DotNetZip - 在C＃中调用Save（流）之前计算最终的zip大小

Question

使用DotNetZip时，是否可以在调用Save（流）之前获得最终的zip文件大小？我有一个应用程序（Window Service），其中包的Stream大小超过100MB，然后将保存包并将即将发布的文件添加到新包中。

我得到same question for web application但不明白答案。在保存在I / O系统之前，有没有办法让DotnetZip找到zip流的大小？

Answer 1

我得到了解决方案。这是code.Now我将创建大小小于100MB的包。

using System;
using System.Collections;
using System.IO;
using Ionic.Zip;
using Ionic.Zlib;

namespace ZipFileSize1
{
    /// <summary>
    /// This source code is generate the specified size Packages from the directory.
    /// </summary>
    class Program
    {
        /// <summary>
        /// The size of Package(100MB).
        /// </summary>
        public static long m_packageSize = 1024 * 1024 * 100;

        /// <summary>
        ///  Main method of program class.
        /// </summary>
        /// <param name="args">Command line argument</param>
        static void Main(string[] args)
        {
            Console.WriteLine("Enter Directory Full Name for Compression : ");
            var dir = Console.ReadLine();
            Console.WriteLine("Zip File saved Location Directory Name : ");
            var savedir = Console.ReadLine();

            //generate the random zip files.

            var zipFile = Path.Combine(savedir, DateTime.Now.Ticks + ".zip");
            ZipFiles(dir, savedir);

            Console.ReadLine();
        }

        /// <summary>
        /// This method generate the package as per the <c>PackageSize</c> declare.
        /// Currently <c>PackageSize</c> is 100MB.
        /// </summary>
        /// <param name="inputFolderPath">Input folder Path.</param>
        /// <param name="outputFolderandFile">Output folder Path.</param>
        public static void ZipFiles(string inputFolderPath, string outputFolderandFile)
        {
            ArrayList ar = GenerateFileList(inputFolderPath); // generate file list
            int trimLength = (Directory.GetParent(inputFolderPath)).ToString().Length;
            // find number of chars to remove   // from original file path
            trimLength += 1; //remove '\'

            // Output file stream of package.
            FileStream ostream;
            byte[] obuffer;

            // Output Zip file name.
            string outPath = Path.Combine(outputFolderandFile, DateTime.Now.Ticks + ".zip");

            ZipOutputStream oZipStream = new ZipOutputStream(File.Create(outPath), true); // create zip stream

            // Compression level of zip file.
            oZipStream.CompressionLevel = CompressionLevel.Default;

            // Initialize the zip entry object.
            ZipEntry oZipEntry = new ZipEntry();

            // numbers of files in file list.
            var counter = ar.Count;
            try
            {
                using (ZipFile zip = new ZipFile())
                {
                    Array.Sort(ar.ToArray());  // Sort the file list array.
                    foreach (string Fil in ar.ToArray()) // for each file, generate a zip entry
                    {
                        if (!Fil.EndsWith(@"/")) // if a file ends with '/' its a directory
                        {

                            if (!zip.ContainsEntry(Path.GetFullPath(Fil.ToString())))
                            {
                                oZipEntry = zip.AddEntry(Path.GetFullPath(Fil.ToString()), Fil.Remove(0, trimLength));
                                counter--;
                                try
                                {
                                    if (counter > 0)
                                    {
                                        if (oZipStream.Position < m_packageSize)
                                        {
                                            oZipStream.PutNextEntry(oZipEntry.FileName);
                                            ostream = File.OpenRead(Fil);
                                            obuffer = new byte[ostream.Length];
                                            ostream.Read(obuffer, 0, obuffer.Length);
                                            oZipStream.Write(obuffer, 0, obuffer.Length);
                                        }

                                        if (oZipStream.Position > m_packageSize)
                                        {
                                            zip.RemoveEntry(oZipEntry);
                                            oZipStream.Flush();
                                            oZipStream.Close(); // close the zip stream.
                                            outPath = Path.Combine(outputFolderandFile, DateTime.Now.Ticks + ".zip"); // create new output zip file when package size.
                                            oZipStream = new ZipOutputStream(File.Create(outPath), true); // create zip stream                                                
                                        }
                                    }
                                    else
                                    {
                                        Console.WriteLine("No more file existed in directory");
                                    }
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine(ex.Message);
                                    zip.RemoveEntry(oZipEntry.FileName);
                                }

                            }
                            else
                            {
                                Console.WriteLine("File Existed {0} in Zip {1}", Path.GetFullPath(Fil.ToString()), outPath);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);

            }
            finally
            {
                oZipStream.Flush();
                oZipStream.Close();// close stream
                Console.WriteLine("Remain Files{0}", counter);
            }
        }

        /// <summary>
        /// This method return the list of files from the directory
        /// Also read the child directory also, but not add the 0 length file.
        /// </summary>
        /// <param name="Dir">Name of directory.</param>
        /// <returns>return the list of all files including into subdirectory files </returns>
        private static ArrayList GenerateFileList(string Dir)
        {
            ArrayList fils = new ArrayList();

            foreach (string file in Directory.GetFiles(Dir, "*.*", SearchOption.AllDirectories)) // add each file in directory
            {
                if (File.ReadAllBytes(file).Length > 0)
                    fils.Add(file);
            }

            return fils; // return file list
        }      
    }
}

Answer 2

  

不明白答案

答案很清楚，但需要对压缩有一些基本的了解。举个例子来看LZW。

归结为：压缩引擎在压缩所有源数据之前不知道压缩数据的最终大小。你宁愿不想这样做两次。

正如dotnetzip的documentation所述，压缩仅在调用ZipFile.Save()时开始。