C# ZipFile.AddDirectory方法代码示例

 /// <summary>
 /// 压缩ZIP文件
 /// </summary>
 /// <param name="fileList">待压缩的文件或目录集合</param>
 /// <param name="zipName">压缩后的文件名</param>
 /// <param name="isDirStruct">是否按目录结构压缩</param>
 public static bool Compress(List<string> fileList, string zipName, bool isDirStruct)
 {
     try
     {
         using (var zip = new ZipFile(Encoding.Default))
         {
             foreach (string path in fileList)
             {
                 string fileName = Path.GetFileName(path);
                 if (Directory.Exists(path))
                 {
                     //按目录结构压缩
                     if (isDirStruct)
                     {
                         zip.AddDirectory(path, fileName);
                     }
                     else//目录下文件压缩到根目录
                     {
                         zip.AddDirectory(path);
                     }
                 }
                 if (File.Exists(path))
                 {
                     zip.AddFile(path);
                 }
             }
             zip.Save(zipName);
             return true;
         }
     }
     catch (Exception)
     {
         return false;
     }
 }

        private static void AddFolderToZip(ZipFile zipFile, string packageRootFolder, string addFolder)
        {
            string sourceFolder = Path.Combine(packageRootFolder, addFolder);

            if (Directory.Exists(sourceFolder))
                zipFile.AddDirectory(sourceFolder, addFolder);
        }

        public byte[] Create(string templateZipFileName, string projectName)
        {
            var temporaryZipFilePath = CreateTemporaryZippedTemplate(templateZipFileName);
            var temporaryRenamingFolder = Path.Combine(_downloadFolder, Path.GetFileNameWithoutExtension(temporaryZipFilePath));

            using (var zipFile = ZipFile.Read(temporaryZipFilePath))
            {
                zipFile.ExtractAll(temporaryRenamingFolder);
            }

            File.Delete(temporaryZipFilePath);

            var renamer = new SolutionRenamer(temporaryRenamingFolder, templateZipFileName, projectName);
            renamer.Rename();

            using (var zipFile = new ZipFile())
            {
                zipFile.AddDirectory(Path.Combine(temporaryRenamingFolder, projectName));
                zipFile.Save(Path.Combine(_downloadFolder, Path.GetFileNameWithoutExtension(temporaryZipFilePath) + ".zip"));
            }

            Directory.Delete(temporaryRenamingFolder, true);

            var bytes = File.ReadAllBytes(temporaryZipFilePath);

            File.Delete(temporaryZipFilePath);

            return bytes;
        }

        public void Run(string containerName)
        {
            if (!this.folderConnection.IsValid())
            {
                throw new DirectoryNotFoundException(string.Format("Unable to access {0}", this.folderConnection.Path));
            }

            List<string> containers = this.cloudConnection.GetContainers();

            if (containers.IsNullOrEmpty() || !containers.Contains(containerName))
            {
                throw new IndexOutOfRangeException(string.Format("Could not find Container: {0}", containerName));
            }

            using (var stream = new MemoryStream())
            {
                using (var zipFile = new ZipFile())
                {
                    zipFile.AddDirectory(this.folderConnection.Path);
                    zipFile.Save(stream);

                    stream.Seek(0, SeekOrigin.Begin);
                    this.cloudConnection.PutStorageItem(containerName, stream, this.folderConnection.ZipName);
                }
            }
        }

            static void Main(string[] args) {
               
               string ZipFilePath = Path.Combine("", "TestArchive.zip");
               if (File.Exists(ZipFilePath)) File.Delete(ZipFilePath);
                var zip = new ZipFile(ZipFilePath);
                zip.AddDirectory("LocalVFS", "LocalVFS/");
                zip.Save();
                zip.Dispose();
                //
                ZipFileSystemConfiguration zc = ZipFileSystemConfiguration.CreateDefaultConfig(ZipFilePath,"_tmp_");
                ZipFileProvider lp = new ZipFileProvider(zc);
                bool exfd = lp.ExistFolder("LocalVFS/", true);
                if (exfd) {
                    lp.DeleteFolder("LocalVFS/");
                }
                byte[] dataTest = Encoding.UTF8.GetBytes("this is a test context!!!");
                File.WriteAllBytes("test.cs", dataTest);
                lp.CreateFolder("LocalVFS/");
                string filepath = lp.CreateFilePath("LocalVFS/", "test.txt");

                //lp.MoveFile("test.cs", filepath);
                byte[] dataTest2 = Encoding.UTF8.GetBytes("this is a test write data!!!");
                using (MemoryStream ms = new MemoryStream(dataTest2)) {
                    lp.WriteFile("LocalVFS/test.txt", ms, true, dataTest2.Length, ContentUtil.UnknownContentType);
                }
                //lp.DeleteFile("LocalVFS/test.txt");
                lp.CopyFolder("LocalVFS/", "localvfs_test/");
                lp.Dispose();
                int jj = 0;
            }

		private void SaveButton_Click(object sender, EventArgs e)
		{
			SaveFileDialog Dialog = new SaveFileDialog();
			Dialog.Filter = "Zip Files (*.zip)|*.zip|AllFiles (*.*)|*.*";
			Dialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
			Dialog.FileName = Path.Combine(Dialog.InitialDirectory, "UGS-Diagnostics.zip");
			if(Dialog.ShowDialog() == DialogResult.OK)
			{
				string DiagnosticsFileName = Path.Combine(DataFolder, "Diagnostics.txt");
				try
				{
					File.WriteAllLines(DiagnosticsFileName, DiagnosticsTextBox.Lines);
				}
				catch(Exception Ex)
				{
					MessageBox.Show(String.Format("Couldn't write to '{0}'\n\n{1}", DiagnosticsFileName, Ex.ToString()));
					return;
				}

				string ZipFileName = Dialog.FileName;
				try
				{
					ZipFile Zip = new ZipFile();
					Zip.AddDirectory(DataFolder);
					Zip.Save(ZipFileName);
				}
				catch(Exception Ex)
				{
					MessageBox.Show(String.Format("Couldn't save '{0}'\n\n{1}", ZipFileName, Ex.ToString()));
					return;
				}
			}
		}

        public void Archive(string rootPath, string archiveFilename, CancellationToken cancellationToken, SimpleProgressCallback progressCallback = null)
        {
            using (ZipFile file = new ZipFile(archiveFilename))
            {
                // add all the files from the report to the zip file
                file.AddDirectory(rootPath);

                // subscribe for the archiving progress event
                file.SaveProgress += (sender, args) =>
                                         {
                                             // check if the cancellation was requested
                                             if (cancellationToken.IsCancellationRequested)
                                             {
                                                 args.Cancel = true;
                                                 return;
                                             }

                                             if (args.EntriesTotal == 0)
                                             {
                                                 // avoid division by zero
                                                 return;
                                             }

                                             progressCallback.TryInvoke((args.EntriesSaved + (args.TotalBytesToTransfer > 0 ? 1.0 * args.BytesTransferred / args.TotalBytesToTransfer : 0.0)) / args.EntriesTotal);
                                         };

                // safe file to disk
                file.Save();

                cancellationToken.ThrowIfCancellationRequested();
            }

            // report operation finished
            progressCallback.TryInvoke(1.0);
        }

        /// <summary>
        /// Create a self-extracting ZIP using the DoNetZip library
        /// </summary>
        public static void CreateSelfExtractingZip(string outputFile, string tempFilePath, string productVersion, string productDescription, string installPath, string postExtractCommand)
        {
            if (!String.IsNullOrEmpty(outputFile))
            {
                using (var zip = new ZipFile())
                {
                    zip.AddDirectory(tempFilePath);

                    var options = new SelfExtractorSaveOptions
                    {
                        ProductName = productDescription,
                        ProductVersion = productVersion,
                        FileVersion = new System.Version(productVersion),
                        Description = productDescription,
                        Copyright = "Copyright © Influence Health 2015",
                        DefaultExtractDirectory = installPath,
                        Flavor = SelfExtractorFlavor.WinFormsApplication,
                        Quiet = false,
                        RemoveUnpackedFilesAfterExecute = false,
                        IconFile = Environment.CurrentDirectory + @"\Installer.ico",
                        ExtractExistingFile = ExtractExistingFileAction.OverwriteSilently,
                        PostExtractCommandLine = postExtractCommand
                    };
                    zip.SaveSelfExtractor(outputFile, options);
                }
            }
        }

 public static void BuildPackage(IEnumerable<string> includes, string outputFileName)
 {
     File.Delete(outputFileName);
     using (var zipFile = new ZipFile(outputFileName))
     {
         foreach (var include in includes)
         {
             if (include.Length < 3)
             {
                 throw new PackManException("Include option must have following format: f|d|p:<value>.");
             }
             char type = char.ToLower(include[0]);
             string value = include.Substring(2);
             switch (type)
             {
                 case 'f':
                     zipFile.AddFile(value);
                     break;
                 case 'd':
                     zipFile.AddDirectory(value);
                     break;
                 case 'p':
                     zipFile.AddSelectedFiles(value,true);
                     break;
             }
         }
         zipFile.Save();
     }
 }

        public HttpResponseMessage GetDiagnostics()
        {
            lock (_lockObj)
            {
                var response = new HttpResponseMessage();
                using (var zip = new ZipFile())
                {
                    foreach (var path in _paths)
                    {
                        if (Directory.Exists(path))
                        {
                            zip.AddDirectory(path, Path.GetFileName(path));
                        }
                    }

                    var ms = new MemoryStream();
                    zip.Save(ms);
                    response.Content = ms.AsContent();
                }
                response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
                response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
                response.Content.Headers.ContentDisposition.FileName = String.Format("dump-{0:MM-dd-H:mm:ss}.zip", DateTime.UtcNow);
                return response;
            }
        }

        public static void DoCopy()
        {
            using (var stream = new StreamReader(@"C:\CopyItems.xml"))
            {
                var deserializer = new XmlSerializer(typeof(List<CopyItem>));

                var items = (List<CopyItem>)deserializer.Deserialize(stream);
                log.Info($"Zdeserializowano elementy: liczba {items.Count}");

                foreach (var item in items)
                {
                    string date = DateTime.Now.ToShortDateString();

                    string mainDirPath = Path.Combine(item.Target, item.Name, date);
                    if (!Directory.Exists(mainDirPath))
                    {
                        Directory.CreateDirectory(mainDirPath);
                    }

                    using (ZipFile zip = new ZipFile())
                    {
                        zip.AddDirectory(item.Source);
                        
                        string path = Path.Combine(mainDirPath, Path.GetFileName(item.Source) + ".zip");

                        zip.Save(path);
                    }
                }
            }
        }

 public void FolderToZip(string sourceDir, string path)
 {
     using (var surveyBackup = new ZipFile()) {
         surveyBackup.AddDirectory(sourceDir);
         surveyBackup.Save(path);
     }
 }

        public FileResult GetPages()
        {
            if (Request.Url != null)
            {
                var zip = new ZipFile();
                zip.AddDirectoryByName("Content");
                zip.AddDirectory(Server.MapPath("~/Content/"), "Content");
                var paths = DtoHelper.GetPaths();
                foreach (var path in paths)
                {
                    var url = Url.Action(path.Action, path.Controller, null, Request.Url.Scheme);
                    if (url != null)
                    {
                        var request = WebRequest.Create(string.Concat(url, Constants.Resources.DownloadParameter));
                        request.Credentials = CredentialCache.DefaultCredentials;
                        var response = (HttpWebResponse)request.GetResponse();
                        var dataStream = response.GetResponseStream();
                        {
                            if (dataStream != null)
                            {
                                zip.AddEntry(path.FileName, dataStream);
                            }
                        }
                    }
                }
                var stream = new MemoryStream();
                zip.Save(stream);
                stream.Position = 0;
                return new FileStreamResult(stream, "application/zip") { FileDownloadName = Constants.Resources.DownloadName };

            }
            return null;
        }

        public static void DoubleZipFileContent(string folderSource, string fileDest, string password)
        {
            using (var zip = new ZipFile())
            {
                zip.AlternateEncoding = Encoding.UTF8;
                zip.AlternateEncodingUsage = ZipOption.Always;

                zip.Password = password;
                zip.Encryption = EncryptionAlgorithm.WinZipAes128;
                zip.AddDirectory(folderSource);
                zip.Save(Path.Combine(folderSource, "content.zip"));
            }

            using (var doubleZip = new ZipFile())
            {
                doubleZip.AlternateEncoding = Encoding.UTF8;
                doubleZip.AlternateEncodingUsage = ZipOption.Always;

                doubleZip.Password = password;
                doubleZip.Encryption = EncryptionAlgorithm.WinZipAes128;
                doubleZip.AddFile(Path.Combine(folderSource, "content.zip"), "");
                doubleZip.Save(fileDest);
            }

            if (File.Exists(Path.Combine(folderSource, "content.zip")))
                File.Delete(Path.Combine(folderSource, "content.zip"));
        }

        public string CreateSolution(IBuildBootstrappedSolutions bootstrapper, SolutionConfiguration configuration)
        {
            configuration.InCodeSubscriptions = true;
            foreach (var endpointConfiguration in configuration.EndpointConfigurations)
            {
                endpointConfiguration.InCodeSubscriptions = configuration.InCodeSubscriptions;
            }

            var solutionData = bootstrapper.BootstrapSolution(configuration);

            var solutionDirectory = SavePath + Guid.NewGuid();

            var solutionFile = SaveSolution(solutionDirectory, solutionData);

            InstallNuGetPackages(solutionDirectory, solutionData, solutionFile, NuGetExe);

            //AddReferencesToNugetPackages(solutionDirectory);

            var zipFilePath = solutionFile.Replace(".sln", ".zip");

            using (var zip = new ZipFile())
            {
                zip.AddDirectory(solutionDirectory, "Solution");
                zip.Save(zipFilePath);
            }

            return zipFilePath;
        }