C# ZipFile.UpdateEntry方法代码示例

        public static string CompileNewXAP(HashSet<string> fullsetOfDlls, string shared)
        {
            var tempPath = Path.Combine(shared, Guid.NewGuid() + ".xap");
            using (
                var stream = Assembly.GetExecutingAssembly()
                                     .GetManifestResourceStream("sl_runner.xap.sl-50-xap.xap"))
            using (var baseZip = ZipFile.Read(stream))
            {
                var set = new HashSet<string>();
                var item = baseZip["AppManifest.xaml"];
                var xml = XDocument.Parse(new StreamReader(item.OpenReader()).ReadToEnd());
                using (
                    var zip = new ZipFile()
                    {
                        CompressionLevel = CompressionLevel.Default,
                        CompressionMethod = CompressionMethod.Deflate
                    })
                {
                    zip.AddEntry("AppManifest.xaml", new byte[] { });
                    foreach (var entry in baseZip.Entries)
                    {
                        if (entry.FileName.Contains(".dll"))
                        {
                            using (var memstream = new MemoryStream())
                            {
                                entry.OpenReader().CopyTo(memstream);
                                memstream.Seek(0, SeekOrigin.Begin);
                                zip.AddEntry(entry.FileName, memstream.ToArray());
                                set.Add(Path.GetFileName(entry.FileName));
                            }
                        }
                    }
                    var desc = xml.DescendantNodes().OfType<XElement>();

                    var parts = desc.Single(it => it.Name.LocalName.Contains("Deployment.Parts"));

                    foreach (var dll in fullsetOfDlls)
                    {
                        if (set.Contains(Path.GetFileName(dll)))
                            continue;
                        set.Add(Path.GetFileName(dll));
                        zip.AddFile(dll, "");
                        parts.Add(new XElement(XName.Get("AssemblyPart", "http://schemas.microsoft.com/client/2007/deployment"),
                                               new XAttribute(
                                                   XName.Get("Name", "http://schemas.microsoft.com/winfx/2006/xaml"),
                                                   Path.GetFileNameWithoutExtension(dll)),
                                               new XAttribute("Source", Path.GetFileName(dll))));
                    }
                    using (var memstream = new MemoryStream())
                    {
                        xml.Save(memstream, SaveOptions.OmitDuplicateNamespaces);
                        zip.UpdateEntry("AppManifest.xaml", memstream.ToArray());
                    }
                    zip.Save(tempPath);
                }
            }
            return tempPath;
        }

        public void UpdateMission(ZkDataContext db, Mission mission, Mod modInfo) {
            var file = mission.Mutator.ToArray();
            var tempName = Path.GetTempFileName() + ".zip";
            File.WriteAllBytes(tempName, file);

            using (var zf = new ZipFile(tempName))
            {
                zf.UpdateEntry("modinfo.lua", Encoding.UTF8.GetBytes(GetModInfo(mission.NameWithVersion, mission.Mod, mission.Name, "ZK")));    // FIXME hardcoded crap
                FixScript(mission, zf, "script.txt");
                var script = FixScript(mission, zf, GlobalConst.MissionScriptFileName);
                modInfo.MissionScript = script;
                //modInfo.ShortName = mission.Name;
                modInfo.Name = mission.NameWithVersion;
                zf.Save();
            }
            mission.Mutator = File.ReadAllBytes(tempName);
            mission.Script = Regex.Replace(mission.Script, "GameType=([^;]+);", (m) => { return string.Format("GameType={0};", mission.NameWithVersion); });
            
            File.Delete(tempName);
            
            var resource = db.Resources.FirstOrDefault(x => x.MissionID == mission.MissionID); 
            if (resource == null)
            {
                resource = new Resource() { DownloadCount = 0, TypeID = ZkData.ResourceType.Mod };
                db.Resources.Add(resource);
            }
            resource.InternalName = mission.NameWithVersion;
            resource.MissionID = mission.MissionID;

            resource.ResourceDependencies.Clear();
            resource.ResourceDependencies.Add(new ResourceDependency() { NeedsInternalName = mission.Map });
            resource.ResourceDependencies.Add(new ResourceDependency() { NeedsInternalName = mission.Mod });
            resource.ResourceContentFiles.Clear();
            

            // generate torrent
            var tempFile = Path.Combine(Path.GetTempPath(), mission.SanitizedFileName);
            File.WriteAllBytes(tempFile, mission.Mutator.ToArray());
            var creator = new TorrentCreator();
            creator.Path = tempFile;
            var torrentStream = new MemoryStream();
            creator.Create(torrentStream);
            try
            {
                File.Delete(tempFile);
            }
            catch { }

            var md5 = Hash.HashBytes(mission.Mutator.ToArray()).ToString();
            resource.ResourceContentFiles.Add(new ResourceContentFile()
            {
                FileName = mission.SanitizedFileName,
                Length = mission.Mutator.Length,
                LinkCount = 1,
                Links = string.Format(MissionFileUrl, mission.MissionID),
                Md5 = md5
            });


            var basePath = GlobalConst.SiteDiskPath + @"\resources\";
            File.WriteAllBytes(string.Format(@"{2}\{0}_{1}.torrent", resource.InternalName.EscapePath(), md5, basePath), torrentStream.ToArray());
            
            File.WriteAllBytes(string.Format(@"{1}\{0}.metadata.xml.gz", resource.InternalName.EscapePath(), basePath),
                                   MetaDataCache.SerializeAndCompressMetaData(modInfo));
            
            File.WriteAllBytes(string.Format(GlobalConst.SiteDiskPath + @"\img\missions\{0}.png", mission.MissionID, basePath), mission.Image.ToArray());

        }

 static string FixScript(Mission mission, ZipFile zf, string scriptName)
 {
     var ms = new MemoryStream();
     zf[scriptName].Extract(ms);
     var script = Encoding.UTF8.GetString(ms.ToArray());
     script = Regex.Replace(script, "GameType=([^;]+);", (m) => { return string.Format("GameType={0};", mission.NameWithVersion); });
     zf.UpdateEntry(scriptName, Encoding.UTF8.GetBytes(script));
     return script;
 }

        public void JitStream_Update_wi13899()
        {
            int fileCount = 12 + _rnd.Next(16);
            string dirToZip = "fodder";
            var files = TestUtilities.GenerateFilesFlat(dirToZip, fileCount, 100, 72000);
            OpenDelegate opener = (name) =>
                {
                    TestContext.WriteLine("Opening {0}", name);
                    Stream s = File.OpenRead(Path.Combine(dirToZip,name));
                    return s;
                };

            CloseDelegate closer = (e, s) =>
                {
                    TestContext.WriteLine("Closing {0}", e);
                    s.Dispose();
                };

            // Two passes: first to call UpdateEntry() when no prior entry exists.
            // Second to call UpdateEntry when a prior entry exists.
            for (int j=0; j < 2; j++)
            {
                string zipFileToCreate = String.Format("wi13899-{0}.zip", j);

                TestContext.WriteLine("");
                TestContext.WriteLine("Creating zipfile {0}", zipFileToCreate);
                if (j!=0)
                {
                    using (var zip = new ZipFile(zipFileToCreate))
                    {
                        foreach (var file in files)
                        {
                            zip.AddEntry(Path.GetFileName(file), "This is the content for file " + file);
                        }
                        zip.Save();
                    }

                    Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                         files.Length);

                    BasicVerifyZip(zipFileToCreate);

                    TestContext.WriteLine("Updating zipfile {0}", zipFileToCreate);
                }

                using (var zip = new ZipFile(zipFileToCreate))
                {
                    foreach (var file in files)
                    {
                        zip.UpdateEntry(Path.GetFileName(file), opener, closer);
                    }
                    zip.Save();
                }

                BasicVerifyZip(zipFileToCreate);
                // verify checksum here?
            }
        }

        private void AddToZip(string name, byte[] data)
        {
            using (var file = new ZipFile(_zipFile))
              {
            if (file.ContainsEntry(name))
            {
              file.UpdateEntry(name, data);
            }
            else
            {
              file.AddEntry(name, data);
            }

            file.Save();
              }
        }

 /// <summary>
 ///     Updating the current version string in storage.
 /// </summary>
 /// <param name="zip"><see cref="ZipFile" /> to store the version string in.</param>
 private void UpdateVersion(ZipFile zip)
 {
     zip.UpdateEntry(VersionFile, GameVersion);
 }

        /// <summary>
        ///     Copy a file entry inside a <see cref="ZipFile" />.
        /// </summary>
        /// <param name="zip"><see cref="ZipFile" /> on which to perform the operation.</param>
        /// <param name="source">Source file name to copy.</param>
        /// <param name="target">Destination file name for the copy.</param>
        private static void ZipCopy(ZipFile zip, string source, string target)
        {
            var entry = zip[source];

            byte[] buffer;
            using (var s = entry.OpenReader()) {
                using (var ms = new MemoryStream()) {
                    s.CopyTo(ms);
                    buffer = ms.ToArray();
                }
            }

            zip.UpdateEntry(target, buffer);
        }

        /// <summary>
        ///     Store a <see cref="UpdateReport" /> in a <see cref="ZipFile" />.
        /// </summary>
        /// <param name="zip"><see cref="ZipFile" /> to write to.</param>
        /// <param name="report"><see cref="UpdateReport" /> to store.</param>
        private static void StoreReport(ZipFile zip, UpdateReport report)
        {
            var textTarget = string.Format(UpdateReportTextFile, report.PreviousVersion, report.UpdateVersion);
            zip.UpdateEntry(textTarget, string.Join(Environment.NewLine, report.Changes.Select(_ => _.ToString())),
                ZipEncoding);

            var yamlTarget = string.Format(UpdateReportYamlFile, report.PreviousVersion, report.UpdateVersion);
            var serializer = new Serializer();
            byte[] yamlBuffer;
            using (var ms = new MemoryStream()) {
                using (TextWriter writer = new StreamWriter(ms, ZipEncoding)) {
                    serializer.Serialize(writer, report);
                    writer.Flush();
                    yamlBuffer = ms.ToArray();
                }
            }
            zip.UpdateEntry(yamlTarget, yamlBuffer);

            var binTarget = string.Format(UpdateReportBinFile, report.PreviousVersion, report.UpdateVersion);
            var formatter = new BinaryFormatter();
            byte[] binBuffer;

            using (var ms = new MemoryStream()) {
                formatter.Serialize(ms, report);
                binBuffer = ms.ToArray();
            }

            zip.UpdateEntry(binTarget, binBuffer);
        }

 /// <summary>
 ///     Serialize a <see cref="RelationDefinition" /> into a <see cref="ZipFile" />.
 /// </summary>
 /// <param name="zip"><see cref="ZipFile" /> to write to.</param>
 /// <param name="definition"><see cref="RelationDefinition" /> to store.</param>
 /// <param name="path">File name inside the storage to write to.</param>
 private static void StoreDefinition(ZipFile zip, RelationDefinition definition, string path)
 {
     using (var ms = new MemoryStream()) {
         using (var writer = new StreamWriter(ms, ZipEncoding)) {
             definition.Serialize(writer);
             writer.Flush();
             zip.UpdateEntry(path, ms.ToArray());
         }
     }
 }

		private static void UpdateXmlEntity(ZipEntry entry, string selector, Action<XElement> update, ZipFile zip, IXmlNamespaceResolver nsResolver)
		{
			var output = new MemoryStream();
			using (var entryStream = entry.OpenReader())
			{
				var xml = XDocument.Load(entryStream);
				update(xml.XPathSelectElement(selector, nsResolver));
				xml.Save(output);
			}
			zip.UpdateEntry(entry.FileName, output.GetBuffer());
			zip.Save();
		}

        public void Update_MultipleSaves_wi10319()
        {
            string zipFileToCreate = "MultipleSaves_wi10319.zip";

            using (ZipFile _zipFile = new ZipFile())
            {
                using (MemoryStream data = new MemoryStream())
                {
                    using (StreamWriter writer = new StreamWriter(data))
                    {
                        writer.Write("Dit is een test string.");
                        writer.Flush();

                        data.Seek(0, SeekOrigin.Begin);
                        _zipFile.AddEntry("test.txt", data);
                        _zipFile.Save(zipFileToCreate);
                        _zipFile.AddEntry("test2.txt", "Esta es un string de test");
                        _zipFile.Save(zipFileToCreate);
                        _zipFile.AddEntry("test3.txt", "this is some content for the entry.");
                        _zipFile.Save(zipFileToCreate);
                    }
                }
            }

            using (ZipFile _zipFile = FileSystemZip.Read(zipFileToCreate))
            {
                using (MemoryStream data = new MemoryStream())
                {
                    using (StreamWriter writer = new StreamWriter(data))
                    {
                        writer.Write("Dit is een andere test string.");
                        writer.Flush();

                        data.Seek(0, SeekOrigin.Begin);

                        _zipFile.UpdateEntry("test.txt", data);
                        _zipFile.Save(zipFileToCreate);
                        _zipFile.UpdateEntry("test2.txt", "Esta es un otro string de test");
                        _zipFile.Save(zipFileToCreate);
                        _zipFile.UpdateEntry("test3.txt", "This is another string for content.");
                        _zipFile.Save(zipFileToCreate);

                    }
                }
            }
        }

		private static void UpdateCsFiles(ZipEntry entry, string slideId, ZipFile zip)
		{
			string code;
			using (var entryStream = entry.OpenReader())
			{
				code = new StreamReader(entryStream).ReadToEnd();
			}
			code = Regex.Replace(code, "(?<=\\[Slide\\(\".*\",\\s*\").+(?=\"\\)\\])", slideId);
			zip.UpdateEntry(entry.FileName, code, Encoding.UTF8);
			zip.Save();
		}

 public void UpdateDatabaseInZip(string zipFilePath, string dbFilePath)
 {
     _log.Info("Updating database in zip");
     using (var zipFile = new ZipFile(zipFilePath)) {
         var existingZip = zipFile.SelectEntries("name = *.bak").FirstOrDefault();
         if (existingZip != null) {
             using (var dbStream = new FileStream(dbFilePath, FileMode.Open)) {
                 zipFile.UpdateEntry(existingZip.FileName, dbStream);
             }
         }
         zipFile.Save();
         _log.DebugFormat("Database updated in {0} from {1}", zipFilePath, dbFilePath);
     }
 }

        public void UpdateZip_UpdateItem_UpdateTwice()
        {
            string filename = "text.txt";
            string contentText1 = "Content 1";
            string contentText2 = "Content 2 - this is longer";

            // select the name of the zip file
            string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_UpdateItem_UpdateTwice.zip");

            // Create the zip file
            Directory.SetCurrentDirectory(TopLevelDir);
            using (ZipFile zip1 = new ZipFile())
            {
                var content1 = new MemoryStream(Encoding.Default.GetBytes(contentText1));
                var entry1 = zip1.UpdateEntry(filename, content1);
                Assert.IsNotNull(entry1);
                zip1.Comment = "UpdateTests::UpdateZip_UpdateItem_UpdateTwice(): This archive will be updated.";
                zip1.Save(zipFileToCreate);

                using (ZipFile zip2 = new ZipFile(zipFileToCreate))
                {
                    var entry = zip2[filename];
                    using (var ms = new MemoryStream())
                    {
                        entry.OpenReader().CopyTo(ms);
                        var content = Encoding.Default.GetString(ms.ToArray());
                        Assert.AreEqual(contentText1, content);
                    }
                }

                var content2 = new MemoryStream(Encoding.Default.GetBytes(contentText2));
                var entry2 = zip1.UpdateEntry(filename, content2);
                Assert.IsNotNull(entry2);
                zip1.Comment = "UpdateTests::UpdateZip_UpdateItem_UpdateTwice(): This archive was updated.";
                zip1.Save(zipFileToCreate);

                using (ZipFile zip3 = new ZipFile(zipFileToCreate))
                {
                    var entry = zip3[filename];
                    using (var ms = new MemoryStream())
                    {
                        entry.OpenReader().CopyTo(ms);
                        var content = Encoding.Default.GetString(ms.ToArray());
                        Assert.AreEqual(contentText2, content);
                    }
                }
            }
        }

        public void UpdateZip_UpdateItem_UpdateMultipleTimesFromStream_SaveAsStream()
        {
            string filename = "text1.txt";
            string filename2 = "text2.txt";
            string contentText1 = "Content 1";
            string contentText2 = "Content 2 - this is longer";
            string contentText3 = "Content 3";

            // select the name of the zip file
            string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_UpdateItem_UpdateMultipleTimes.zip");
            string zipFileToSaveAs = Path.Combine(TopLevelDir, "UpdateZip_UpdateItem_UpdateMultipleTimes_New.zip");

            #region Create the zip file

            Directory.SetCurrentDirectory(TopLevelDir);
            using (ZipFile zipSave = new ZipFile())
            {
                var content1 = new MemoryStream(Encoding.Default.GetBytes(contentText1));
                var entry1 = zipSave.UpdateEntry(filename, content1);
                Assert.IsNotNull(entry1);

                var content2 = new MemoryStream(Encoding.Default.GetBytes(contentText2));
                var entry2 = zipSave.UpdateEntry(filename2, content2);
                Assert.IsNotNull(entry2);
                zipSave.Comment = "UpdateTests::UpdateZip_UpdateItem_UpdateMultipleTimes(): This archive will be updated.";
                zipSave.Save(zipFileToCreate);
            }
            using (ZipFile zipTest = new ZipFile(zipFileToCreate))
            {
                var entry = zipTest[filename];
                using (var ms = new MemoryStream())
                {
                    entry.OpenReader().CopyTo(ms);
                    var content = Encoding.Default.GetString(ms.ToArray());
                    Assert.AreEqual(contentText1, content);
                }
            }

            #endregion

            var zipData = File.ReadAllBytes(zipFileToCreate);
            var sourceStream = new MemoryStream(zipData);
            using (ZipFile zipSave = ZipFile.Read(sourceStream))
            {
                var content2 = new MemoryStream(Encoding.Default.GetBytes(contentText2));
                var entry2 = zipSave.UpdateEntry(filename, content2);
                Assert.IsNotNull(entry2);
                zipSave.Comment = "UpdateTests::UpdateZip_UpdateItem_UpdateMultipleTimes(): This archive was updated once.";

                var memoryStream = new MemoryStream(); //Attention: the source stream can't be disposed, as its needed to read not edited entries on the next save
                zipSave.Save(memoryStream);
                File.WriteAllBytes(zipFileToSaveAs, memoryStream.ToArray());
                Assert.IsTrue(ZipFile.CheckZip(zipFileToSaveAs));

                var content3 = new MemoryStream(Encoding.Default.GetBytes(contentText3));
                var entry3 = zipSave.UpdateEntry(filename, content3);
                Assert.IsNotNull(entry3);
                zipSave.Comment = "UpdateTests::UpdateZip_UpdateItem_UpdateMultipleTimes(): This archive was updated twice.";

                memoryStream = new MemoryStream();
                zipSave.Save(memoryStream);
                File.WriteAllBytes(zipFileToSaveAs, memoryStream.ToArray());
            }

            Assert.IsTrue(ZipFile.CheckZip(zipFileToSaveAs));
            using (ZipFile zipTest = new ZipFile(zipFileToSaveAs))
            {
                var entry = zipTest[filename];
                using (var ms = new MemoryStream())
                {
                    entry.OpenReader().CopyTo(ms);
                    var content = Encoding.Default.GetString(ms.ToArray());
                    Assert.AreEqual(contentText3, content);
                }
            }
        }