C# ZipFile.AddSelectedFiles方法代码示例

 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 virtual void Export(Site site, System.IO.Stream outputStream)
        {
            ExportLabels(site);
            using (ZipFile zipFile = new ZipFile())
            {
                zipFile.AddSelectedFiles("*.*", new Label(site).PhysicalPath, "");

                zipFile.Save(outputStream);
            }
        }

 private void BackupFiles()
 {
     EMMServer server = Manager.Server;
     string backupFile = Path.Combine(server.Settings.BackupRoot, string.Format("backup-{0:yyyyMMdd-HHmmss}.zip", DateTime.Now));
     using (ZipFile zip = new ZipFile())
     {
         zip.AddSelectedFiles("*.txt", server.Settings.MinecraftRoot, @"minecraft");
         zip.AddSelectedFiles("*.jar", server.Settings.MinecraftRoot, @"minecraft");
         zip.AddSelectedFiles("*.properties", server.Settings.MinecraftRoot, @"minecraft");
         zip.AddDirectory(mWorldPath, @"minecraft\" + Path.GetFileName(mWorldPath));
         try
         {
             zip.Save(backupFile);
         }
         catch (Exception e)
         {
             server.RaiseServerMessage(string.Format("ERROR: Unable to save backup! {0}", e.Message));
         }
     }
 }

        public void Export(Site site, IEnumerable<Label> labels, IEnumerable<string> categories, Stream outputStream)
        {
            if ((labels == null || labels.Count() == 0) && (categories == null || categories.Count() == 0))
            {
                this.ExportLabelsToDisk(site);

                using (ZipFile zipFile = new ZipFile())
                {
                    zipFile.AddSelectedFiles("*.json", new LabelPath(site).PhysicalPath, "");

                    zipFile.Save(outputStream);
                }
            }
            else
            {
                var tempFolder = GetImportExportTempFolder(site);
                Kooboo.IO.IOUtility.DeleteDirectory(tempFolder, true);

                if (labels != null)
                {
                    foreach (var item in labels)
                    {
                        var label = _rawLabelProvider.Get(item);
                        if (label != null)
                        {
                            var storage = GetStorage(GetImportExportLabelFile(site, label.Category));
                            storage.Add(label);
                        }
                    }
                }

                if (categories != null)
                {
                    foreach (var item in categories)
                    {
                        foreach (var label in _rawLabelProvider.GetLabels(site, item).ToArray())
                        {
                            var storage = GetStorage(GetImportExportLabelFile(site, label.Category));
                            storage.Add(label);
                        }
                    }
                }

                using (ZipFile zipFile = new ZipFile())
                {
                    zipFile.AddSelectedFiles("*.json", tempFolder, "");

                    zipFile.Save(outputStream);
                }
                Kooboo.IO.IOUtility.DeleteDirectory(tempFolder, true);

            }
        }

        /// <summary>
        /// Compress the binaries into ZIP file
        /// </summary>
        /// <param name="path">
        /// The path.
        /// </param>
        /// <param name="outFile">
        /// The out File.
        /// </param>
        private void CompressBinariesDir(string path, string outFile)
        {
            var dir = Path.GetDirectoryName(outFile);
            Directory.CreateDirectory(dir);
            if (File.Exists(outFile))
            {
                File.Delete(outFile);
            }

            string inDir = Path.GetFullPath(path);
            using (var zip = new ZipFile())
            {
                zip.CompressionLevel = CompressionLevel.BestCompression;
                zip.AddSelectedFiles("name != *.pdb", inDir, string.Empty, true);
                zip.Save(outFile);
            }
        }

        public void ShellApplication_SelectedFiles_Unzip()
        {
            string zipFileToCreate = Path.Combine(TopLevelDir, "ShellApplication_SelectedFiles_Unzip.zip");

            TestContext.WriteLine("ZipFile version:  {0}", ZipFile.LibraryVersion);

            // create and fill the directories
            string extractDir = "extract";
            string dirToZip = "files";
            TestContext.WriteLine("creating dir '{0}' with files", dirToZip);
            Directory.CreateDirectory(dirToZip);

            int numFilesToAdd = _rnd.Next(5) + 6;
            int numFilesAdded = 0;
            int baseSize = _rnd.Next(0x100ff) + 8000;
            int nFilesInSubfolders = 0;
            Dictionary<string, byte[]> checksums = new Dictionary<string, byte[]>();
            var flist = new List<string>();
            for (int i = 0; i < numFilesToAdd && nFilesInSubfolders < 2; i++)
            {
                string fileName = string.Format("Test{0}.txt", i);
                if (i != 0)
                {
                    int x = _rnd.Next(4);
                    if (x != 0)
                    {
                        string folderName = string.Format("folder{0}", x);
                        fileName = Path.Combine(folderName, fileName);
                        if (!Directory.Exists(Path.Combine(dirToZip, folderName)))
                            Directory.CreateDirectory(Path.Combine(dirToZip, folderName));
                        nFilesInSubfolders++;
                    }
                }
                fileName = Path.Combine(dirToZip, fileName);
                TestUtilities.CreateAndFillFileBinary(fileName, baseSize + _rnd.Next(28000));
                var key = Path.GetFileName(fileName);
                var chk = TestUtilities.ComputeChecksum(fileName);
                checksums.Add(key, chk);
                flist.Add(fileName);
                numFilesAdded++;
            }

            // Create the zip archive
            var sw = new System.IO.StringWriter();
            using (ZipFile zip1 = new ZipFile())
            {
                zip1.StatusMessageTextWriter = sw;
                //zip1.StatusMessageTextWriter = Console.Out;
                zip1.AddSelectedFiles("*.*", dirToZip, "", true);
                zip1.Save(zipFileToCreate);
            }
            TestContext.WriteLine(sw.ToString());


            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), numFilesAdded,
                                 "Incorrect number of entries in the zip file.");

            // run the unzip script
            string script = GetScript("VbsUnzip-ShellApp.vbs");

            this.Exec(cscriptExe,
                      String.Format("\"{0}\" {1} {2}", script, zipFileToCreate, Path.Combine(TopLevelDir, extractDir)));

            // check the files in the extract dir
            foreach (var fqPath in flist)
            {
                var f = Path.GetFileName(fqPath);
                var extractedFile = fqPath.Replace("files", "extract");
                Assert.IsTrue(File.Exists(extractedFile), "File does not exist ({0})", extractedFile);
                var chk = TestUtilities.ComputeChecksum(extractedFile);
                Assert.AreEqual<String>(TestUtilities.CheckSumToString(checksums[f]),
                                        TestUtilities.CheckSumToString(chk),
                                        String.Format("Checksums for file {0} do not match.", f));
                checksums.Remove(f);
            }

            Assert.AreEqual<Int32>(0, checksums.Count, "Not all of the expected files were found in the extract directory.");
        }

        public void Selector_AddSelectedFiles_Checkcase_directory_2()
        {
            string zipFileToCreate = "AddSelectedFiles_Checkcase.zip";
            string shortDirToZip = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()).ToUpper();
            string dirToZip = Path.Combine(TopLevelDir, shortDirToZip); // fully qualified
            var files = TestUtilities.GenerateFilesFlat(shortDirToZip);
            string keyword = "Ammon";
            int n = _rnd.Next(3)+2;
            for (int i=0; i < n; i++)
            {
                Directory.SetCurrentDirectory(dirToZip);
                string subdir = keyword + i;
                TestUtilities.GenerateFilesFlat(subdir);
                Directory.SetCurrentDirectory(subdir);
                var f2 = Directory.GetFiles(".", "*.*");
                int k = 2;
                Array.ForEach(f2, x => {
                        File.Move(x, String.Format("{0}.{1:D5}.txt", keyword.ToUpper(), k++)); });
            }

            Directory.SetCurrentDirectory(TopLevelDir);

            TestContext.WriteLine("Create zip file");
            using (ZipFile zip1 = new ZipFile())
            {
                var criterion = "name = *\\" + keyword + "?\\*.txt";
                zip1.AddSelectedFiles(criterion, ".\\" + shortDirToZip, "files", true);
                zip1.Save(zipFileToCreate);
            }

            TestContext.WriteLine("Verify case of entry FileNames");
            int nEntries = 0;
            // now, verify that we have not downcased entry.FileName
            using (ZipFile zip2 = new ZipFile(zipFileToCreate))
            {
                foreach (var entry in zip2.Entries)
                {
                    TestContext.WriteLine("Check {0}", entry.FileName);
                    Assert.AreNotEqual<String>(entry.FileName,
                                               entry.FileName.ToLower(),
                                               entry.FileName);
                    nEntries++;
                }
            }
            Assert.IsFalse(nEntries < 3, "not enough entries");
        }

        public void Selector_AddSelectedFiles_Checkcase_directory()
        {
            string zipFileToCreate = "AddSelectedFiles_Checkcase.zip";
            string dirToZip = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()).ToUpper();
            var files = TestUtilities.GenerateFilesFlat(dirToZip);

            var txtFiles = Directory.GetFiles(dirToZip, "*.txt",
                                              SearchOption.AllDirectories);

            Assert.IsFalse(txtFiles.Length < 3, "not enough entries (n={0})",
                           txtFiles.Length);

            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddSelectedFiles("*.txt", dirToZip);
                zip1.Save(zipFileToCreate);
            }

            int nEntries = 0;
            // now, verify that we have not downcased the filenames
            using (ZipFile zip2 = new ZipFile(zipFileToCreate))
            {
                foreach (var entry in zip2.Entries)
                {
                    Assert.IsFalse(entry.FileName.Equals(entry.FileName.ToLower()));
                    nEntries++;
                }
            }
            Assert.IsFalse(nEntries < 3, "not enough entries (n={0})", nEntries);
        }

        public void Selector_AddSelectedFiles_Checkcase_file()
        {
            string zipFileToCreate = "AddSelectedFiles_Checkcase.zip";
            string dirToZip = Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
            var files = TestUtilities.GenerateFilesFlat(dirToZip);

            Directory.SetCurrentDirectory(dirToZip);
            var f2 = Directory.GetFiles(".", "*.*");
            Array.ForEach(f2, x => { File.Move(x,Path.GetFileName(x).ToUpper()); });
            Directory.SetCurrentDirectory(TopLevelDir);

            var txtFiles = Directory.GetFiles(dirToZip, "*.txt",
                                              SearchOption.AllDirectories);

            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddSelectedFiles("*.txt", dirToZip);
                zip1.Save(zipFileToCreate);
            }

            int nEntries = 0;
            // now, verify that we have not downcased the filenames
            using (ZipFile zip2 = new ZipFile(zipFileToCreate))
            {
                foreach (var entry in zip2.Entries)
                {
                    Assert.IsFalse(entry.FileName.Equals(entry.FileName.ToLower()));
                    nEntries++;
                }
            }
            Assert.IsFalse(nEntries < 2, "not enough entries");

        }

        public void Selector_AddSelectedFiles_2()
        {
            string zipFileToCreate = "Selector_AddSelectedFiles_2.zip";
            string dirToZip = Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
            var files = TestUtilities.GenerateFilesFlat(dirToZip);
            var txtFiles = Directory.GetFiles(dirToZip, "*.txt", SearchOption.AllDirectories);

            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddSelectedFiles("*.txt");
                zip1.Save(zipFileToCreate);
            }

            Assert.AreEqual<Int32>(0, TestUtilities.CountEntries(zipFileToCreate));

            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddSelectedFiles("*.txt", true);
                zip1.Save(zipFileToCreate);
            }

            Assert.AreEqual<Int32>(txtFiles.Length, TestUtilities.CountEntries(zipFileToCreate));
            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddSelectedFiles("*.txt", ".", true);
                zip1.Save(zipFileToCreate);
            }

            Assert.AreEqual<Int32>(txtFiles.Length, TestUtilities.CountEntries(zipFileToCreate));

        }

        public void Selector_AddSelectedFiles()
        {
            Directory.SetCurrentDirectory(TopLevelDir);

            Trial[] trials = new Trial[]
                {
                    new Trial { Label = "name", C1 = "name = *.txt", C2 = "name = *.bin" },
                    new Trial { Label = "name (shorthand)", C1 = "*.txt", C2 = "*.bin" },
                    new Trial { Label = "attributes (Hidden)", C1 = "attributes = H", C2 = "attributes != H" },
                    new Trial { Label = "attributes (ReadOnly)", C1 = "attributes = R", C2 = "attributes != R" },
                    new Trial { Label = "mtime", C1 = "mtime < 2007-01-01", C2 = "mtime > 2007-01-01" },
                    new Trial { Label = "atime", C1 = "atime < 2007-01-01", C2 = "atime > 2007-01-01" },
                    new Trial { Label = "ctime", C1 = "ctime < 2007-01-01", C2 = "ctime > 2007-01-01" },
                    new Trial { Label = "size", C1 = "size < 7500", C2 = "size >= 7500" },

                    new Trial { Label = "name & size",
                                C1 = "name = *.bin AND size > 7500",
                                C2 = "name != *.bin  OR  size <= 7500",
                    },

                    new Trial { Label = "name, size & attributes",
                                C1 = "name = *.bin AND size > 8kb and attributes = H",
                                C2 = "name != *.bin  OR  size <= 8kb or attributes != H",
                    },

                    new Trial { Label = "name, size, time & attributes.",
                                C1 = "name = *.bin AND size > 7k and mtime < 2007-01-01 and attributes = H",
                                C2 = "name != *.bin  OR  size <= 7k or mtime > 2007-01-01 or attributes != H",
                    },
                };

            _txrx = TestUtilities.StartProgressMonitor("AddSelectedFiles", "AddSelectedFiles", "starting up...");

            string[] zipFileToCreate = {
                Path.Combine(TopLevelDir, "Selector_AddSelectedFiles-1.zip"),
                Path.Combine(TopLevelDir, "Selector_AddSelectedFiles-2.zip")
            };

            Assert.IsFalse(File.Exists(zipFileToCreate[0]), "The zip file '{0}' already exists.", zipFileToCreate[0]);
            Assert.IsFalse(File.Exists(zipFileToCreate[1]), "The zip file '{0}' already exists.", zipFileToCreate[1]);

            int count1, count2;

            SetupFiles();
            var topLevelFiles = Directory.GetFiles(fodderDirectory, "*.*", SearchOption.TopDirectoryOnly);

            string currentDir = Directory.GetCurrentDirectory();
            _txrx.Send(String.Format("pb 0 max {0}", 2 * (trials.Length + 1)));

            _txrx.Send("pb 0 step");

            for (int m = 0; m < trials.Length; m++)
            {
                _txrx.Send("test AddSelectedFiles");
                _txrx.Send("pb 1 max 4");
                _txrx.Send(String.Format("status test {0}/{1}: creating zip #1/2",
                                         m + 1, trials.Length));
                TestContext.WriteLine("===============================================");
                TestContext.WriteLine("AddSelectedFiles() [{0}]", trials[m].Label);
                using (ZipFile zip1 = new ZipFile())
                {
                    zip1.AddSelectedFiles(trials[m].C1, fodderDirectory, "");
                    zip1.Save(zipFileToCreate[0]);
                }
                count1 = TestUtilities.CountEntries(zipFileToCreate[0]);
                TestContext.WriteLine("C1({0}) Count({1})", trials[m].C1, count1);
                _txrx.Send("pb 1 step");
                System.Threading.Thread.Sleep(100);
                _txrx.Send("pb 0 step");

                _txrx.Send(String.Format("status test {0}/{1}: creating zip #2/2",
                                         m + 1, trials.Length));
                using (ZipFile zip1 = new ZipFile())
                {
                    zip1.AddSelectedFiles(trials[m].C2, fodderDirectory, "");
                    zip1.Save(zipFileToCreate[1]);
                }
                count2 = TestUtilities.CountEntries(zipFileToCreate[1]);
                TestContext.WriteLine("C2({0}) Count({1})", trials[m].C2, count2);
                Assert.AreEqual<Int32>(topLevelFiles.Length, count1 + count2);
                _txrx.Send("pb 1 step");

                /// =======================================================
                /// Now, select entries from that ZIP
                _txrx.Send(String.Format("status test {0}/{1}: selecting zip #1/2",
                                         m + 1, trials.Length));
                using (ZipFile zip1 = ZipFile.Read(zipFileToCreate[0]))
                {
                    var selected1 = zip1.SelectEntries(trials[m].C1);
                    Assert.AreEqual<Int32>(selected1.Count, count1);
                }
                _txrx.Send("pb 1 step");

                _txrx.Send(String.Format("status test {0}/{1}: selecting zip #2/2",
                                         m + 1, trials.Length));
                using (ZipFile zip1 = ZipFile.Read(zipFileToCreate[1]))
                {
                    var selected2 = zip1.SelectEntries(trials[m].C2);
                    Assert.AreEqual<Int32>(selected2.Count, count2);
                }
//.........这里部分代码省略.........

        public void Selector_Twiddle_wi10153()
        {
            // workitem 10153:
            //
            // When calling AddSelectedFiles(String,String,String,bool), and when the
            // actual filesystem path uses mixed case, but the specified directoryOnDisk
            // argument is downcased, AND when the filename contains a ~ (weird, I
            // know), verify that the path replacement works as advertised, and entries
            // are rooted in the directoryInArchive specified path.

            string zipFileToCreate = Path.Combine(TopLevelDir, "Selector_Twiddle.zip");
            string dirToZip = "dirToZip";
            var keyword = "Gamma";
            var files = TestUtilities.GenerateFilesFlat(dirToZip);
            int k = 0;
            Directory.SetCurrentDirectory(dirToZip);
            Array.ForEach(files, x => {
                    File.Move(Path.GetFileName(x),
                              String.Format("~{0}.{1:D5}.txt", keyword, k++));
                });
            Directory.SetCurrentDirectory(TopLevelDir);

            using (ZipFile zip = new ZipFile())
            {
                // must use ToLower to force case mismatch
                zip.AddSelectedFiles("name != *.zip*", dirToZip.ToLower(), "", true);
                zip.Save(zipFileToCreate);
            }

            int nEntries = 0;
            using (ZipFile zip = ZipFile.Read(zipFileToCreate))
            {
                foreach (var e in zip)
                    TestContext.WriteLine("entry {0}", e.FileName);

                TestContext.WriteLine("");

                foreach (var e in zip)
                {
                    TestContext.WriteLine("check {0}", e.FileName);
                    Assert.IsFalse(e.FileName.Contains("/"),
                                   "The filename contains a path, but shouldn't");
                    nEntries++;
                }
            }
            Assert.IsTrue(nEntries>2, "Not enough entries");
        }

        public void Selector_SelectFiles_DirName_wi9176()
        {
            // workitem 9176
            //Directory.SetCurrentDirectory(TopLevelDir);

            _txrx= TestUtilities.StartProgressMonitor("SelectFiles-DirName",
                                                      "Select Files by DirName",
                                                      "workitem 9176");

            SetupFiles();

            var binFiles = Directory.GetFiles(fodderDirectory, "*.bin", SearchOption.AllDirectories);

            int[] eCount = new int[2];
            _txrx.Send("pb 0 max 2");
            for (int i = 0; i < 2; i++)
            {
                string zipFileToCreate = Path.Combine(TopLevelDir,
                                                      String.Format("Selector_SelectFiles_DirName_wi9176-{0}.zip", i));
                _txrx.Send("pb 1 max 4");
                _txrx.Send("pb 1 value 0");
                string d = fodderDirectory;
                if (i == 1) d += "\\";
                TestContext.WriteLine("===============================================");
                TestContext.WriteLine("AddSelectedFiles(cycle={0})", i);
                using (ZipFile zip1 = new ZipFile())
                {
                    zip1.AddSelectedFiles("name = *.bin", d, "", true);
                    _txrx.Send("pb 1 step");
                    zip1.Save(zipFileToCreate);
                }
                _txrx.Send("pb 1 step");

                Assert.AreEqual<Int32>(TestUtilities.CountEntries(zipFileToCreate), binFiles.Length,
                                       "The Zip file has the wrong number of entries.");

                _txrx.Send("pb 2 step");

                using (ZipFile zip1 = ZipFile.Read(zipFileToCreate))
                {
                    foreach (var e in zip1)
                    {
                        if (e.FileName.Contains("/")) eCount[i]++;
                    }
                }
                _txrx.Send("pb 1 step");

                if (i==1)
                    Assert.AreEqual<Int32>(eCount[0], eCount[1],
                                           "Inconsistent results when the directory includes a path.", i);

                _txrx.Send("pb 0 step");
            }
        }

        public void Selector_SelectFiles_DirName_wi8245_2()
        {
            // workitem 8245
            string zipFileToCreate = Path.Combine(TopLevelDir, "Selector_SelectFiles_DirName_wi8245_2.zip");
            //Directory.SetCurrentDirectory(TopLevelDir);
            SetupFiles();

            var fodderFiles = Directory.GetFiles(fodderDirectory, "*.*", SearchOption.AllDirectories);

            TestContext.WriteLine("===============================================");
            TestContext.WriteLine("AddSelectedFiles()");
            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddSelectedFiles(fodderDirectory, null, "fodder", true);
                zip1.Save(zipFileToCreate);
            }

            Assert.AreEqual<Int32>(TestUtilities.CountEntries(zipFileToCreate), fodderFiles.Length,
                                   "The Zip file has the wrong number of entries.");
        }

        private void Zipit(object sender, DoWorkEventArgs e)
        {
            int delay = 1200; // ms to keep form open after completion
            try
            {
                using (var zip = new ZipFile())
                {
                    zip.AddSelectedFiles(selectionCriteria, ".", "", true);
                    zip.SaveProgress += this.SaveProgress;
                    zip.Save(zipfileName);
                }
            }
            catch (Exception ex1)
            {
                this.label1.Text = "Exception: " +  ex1.ToString();
                delay = 4000;
            }

            var timer1 =  new System.Timers.Timer(delay);
            timer1.Enabled = true;
            timer1.AutoReset = false;
            timer1.Elapsed += this.OnTimerEvent;
        }