public static FirefoxProfile FromBase64String(string base64) { string text = FileUtilities.GenerateRandomTempDirectoryName("webdriver.{0}.duplicated"); byte[] buffer = Convert.FromBase64String(base64); using (MemoryStream memoryStream = new MemoryStream(buffer)) { using (ZipStorer zipStorer = ZipStorer.Open(memoryStream, FileAccess.Read)) { List <ZipStorer.ZipFileEntry> list = zipStorer.ReadCentralDirectory(); foreach (ZipStorer.ZipFileEntry current in list) { string path = current.FilenameInZip.Replace('/', Path.DirectorySeparatorChar); string destinationFileName = Path.Combine(text, path); zipStorer.ExtractFile(current, destinationFileName); } } } return(new FirefoxProfile(text, true)); }
public Card[] ReadMSE(string mseset, bool repalceOld) { //解压所有文件 using (ZipStorer zips = ZipStorer.Open(mseset, FileAccess.Read)) { zips.EncodeUTF8 = true; List <ZipStorer.ZipFileEntry> files = zips.ReadCentralDir(); int count = files.Count; int i = 0; foreach (ZipStorer.ZipFileEntry file in files) { worker.ReportProgress(i / count, string.Format("{0}/{1}", i, count)); string savefilename = MyPath.Combine(mseHelper.ImagePath, file.FilenameInZip); zips.ExtractFile(file, savefilename); } } string setfile = MyPath.Combine(mseHelper.ImagePath, "set"); return(mseHelper.ReadCards(setfile, repalceOld)); }
private void Load(Stream _stream) { if (_stream == null) { throw new InvalidOperationException("No Stream to load!"); } using (ZipStorer zip = ZipStorer.Open(_stream, FileAccess.Read)) { // Read the central directory collection List <ZipStorer.ZipFileEntry> dir = zip.ReadCentralDir(); foreach (ZipStorer.ZipFileEntry entry in dir) { Stream _fileStream = new MemoryStream(); zip.ExtractFile(entry, _fileStream); if (entry.FilenameInZip == "meta.xml") { _metaData = XDocument.Parse(StreamToString(_fileStream)); } else if (entry.FilenameInZip == "META-INF\\manifest.xml" || entry.FilenameInZip == "META-INF/manifest.xml" || entry.FilenameInZip == "manifest.xml") { _manifestData = XDocument.Parse(StreamToString(_fileStream)); } else if (entry.FilenameInZip == "content.xml") { _contentData = XDocument.Parse(StreamToString(_fileStream)); } else if (entry.FilenameInZip.StartsWith("attachments")) { //附件 byte[] buf = new byte[_fileStream.Length]; _fileStream.Position = 0; int count = _fileStream.Read(buf, 0, buf.Length); attachments.Add(entry.FilenameInZip, buf); } _fileStream.Close(); } zip.Close(); } }
//ディレクトリをzipファイルに書き込む private static void WriteDirToZip(ZipStorer zip, DirectoryInfo srcDir, string pathInZip) { var files = srcDir.EnumerateFiles(); files = files.Where(e => e.Name != "mimetype"); //mimetypeファイルを除く foreach (var file in files) { var ext = file.Extension; ZipStorer.Compression compression; //ファイル形式によって圧縮形式を変える switch (ext) { case "jpg": //画像ファイルは圧縮しない(時間の無駄なので) case "JPEG": case "png": case "PNG": case "gif": case "GIF": compression = ZipStorer.Compression.Store; break; case "EPUB": case "epub": continue; //EPUBファイルは格納しない default: compression = ZipStorer.Compression.Deflate; //通常のファイルは圧縮する break; } WriteFileToZip(zip, file, pathInZip + file.Name, compression); } //残りのディレクトリを再帰的に書き込む var dirs = srcDir.EnumerateDirectories(); foreach (var dir in dirs) { WriteDirToZip(zip, dir, pathInZip + dir.Name + "/"); } }
static void DoBackup() { if (!Directory.Exists(DataBackupDirectory)) { Directory.CreateDirectory(DataBackupDirectory); } string backupFileName = String.Format(BackupFileNameFormat, DateTime.Now); // localized backupFileName = Path.Combine(DataBackupDirectory, backupFileName); using (FileStream fs = File.Create(backupFileName)) { using (ZipStorer backupZip = ZipStorer.Create(fs, "")) { foreach (string dataFileName in FilesToBackup) { if (File.Exists(dataFileName)) { backupZip.AddFile(ZipStorer.Compression.Deflate, dataFileName, dataFileName, ""); } } } } }
public void WriteObjectItem(Stream stream, Func <int, object> getItem) { DateTime zipTime = DateTime.Now; using (ZipStorer zipStorer = ZipStorer.Create(stream)) { object item; int i = 0; while ((item = getItem(i)) != null) { using (MemoryStream unzipStraem = new MemoryStream()) { base.WriteObject(unzipStraem, item); unzipStraem.Position = 0; zipStorer.AddStream(ZipStorer.Compression.Deflate, i.ToString(), unzipStraem, zipTime); } i++; } } }
private static void Main() { FileInfo binaries = new FileInfo(BinariesFileName); if (binaries.Exists) { binaries.Delete(); } using (ZipStorer zs = ZipStorer.Create(binaries.FullName, "")) { foreach (string file in FileList) { FileInfo fi = new FileInfo(file); if (!fi.Exists) { return; // abort if any of the files do not exist } zs.AddFile(ZipStorer.Compression.Deflate, fi.FullName, fi.Name, ""); } } }
private Boolean UnzipInstaller(String installerZipAddress) { try { var installerZip = ZipStorer.Open(installerZipAddress, FileAccess.Read); var zipDir = installerZip.ReadCentralDir(); foreach (var file in zipDir) { installerZip.ExtractFile(file, Path.Combine(_targetInstallFolder, file.FilenameInZip)); } installerZip.Close(); return(true); } catch (Exception e) { PowerPointLabs.Views.ErrorDialogWrapper.ShowDialog("Failed to install", "An error occurred while installing PowerPointLabs", e); } return(false); }
/// <summary> /// Converts a base64-encoded string into a <see cref="FirefoxProfile"/>. /// </summary> /// <param name="base64">The base64-encoded string containing the profile contents.</param> /// <returns>The constructed <see cref="FirefoxProfile"/>.</returns> public static FirefoxProfile FromBase64String(string base64) { string destinationDirectory = FileUtilities.GenerateRandomTempDirectoryName("webdriver.{0}.duplicated"); byte[] zipContent = Convert.FromBase64String(base64); using (MemoryStream zipStream = new MemoryStream(zipContent)) { using (ZipStorer profileZipArchive = ZipStorer.Open(zipStream, FileAccess.Read)) { List <ZipStorer.ZipFileEntry> entryList = profileZipArchive.ReadCentralDirectory(); foreach (ZipStorer.ZipFileEntry entry in entryList) { string fileName = entry.FilenameInZip.Replace('/', Path.DirectorySeparatorChar); string destinationFile = Path.Combine(destinationDirectory, fileName); profileZipArchive.ExtractFile(entry, destinationFile); } } } return(new FirefoxProfile(destinationDirectory, true)); }
private static Dictionary <string, byte[]> ExtractZipFromMemoryStream(Stream stream) { var zip = ZipStorer.Open(stream, FileAccess.Read); var dir = zip.ReadCentralDir(); var files = new Dictionary <string, byte[]>(); // Look for the desired file foreach (var entry in dir) { var fileBytes = new byte[0]; zip.ExtractFile(entry, out fileBytes); files.Add(entry.ToString(), fileBytes); } zip.Close(); return(files); }
public void Test_Common() { Assert.Throws(typeof(ArgumentNullException), () => { ZipStorer.Open("", FileAccess.Read); }); string fileName = TestStubs.GetTempFilePath("test.zip"); using (ZipStorer zip = ZipStorer.Create(fileName, "test")) { using (MemoryStream csvStream = new MemoryStream(Encoding.ASCII.GetBytes(TestStubs.CSVData))) { zip.AddStream(ZipStorer.Compression.Deflate, "csv_file.csv", csvStream, DateTime.Now, ""); } Assert.Throws(typeof(InvalidOperationException), () => { zip.ReadCentralDir(); }); ZipStorer xzip = null; Assert.Throws(typeof(ArgumentNullException), () => { xzip = ZipStorer.RemoveEntries(xzip, null); }); Assert.Throws(typeof(ArgumentNullException), () => { xzip = ZipStorer.RemoveEntries(xzip, null); }); } using (ZipStorer zip = ZipStorer.Open(fileName, FileAccess.Read)) { Assert.Throws(typeof(ArgumentNullException), () => { zip.FindFile(null); }); ZipStorer.ZipFileEntry entry = zip.FindFile("invalid"); Assert.IsNull(entry); entry = zip.FindFile("csv_file.csv"); Assert.IsNotNull(entry); using (MemoryStream csvStream = new MemoryStream()) { Assert.Throws(typeof(ArgumentNullException), () => { zip.ExtractStream(entry, null); }); zip.ExtractStream(entry, csvStream); csvStream.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(csvStream, Encoding.ASCII)) { string text = reader.ReadToEnd(); Assert.AreEqual(TestStubs.CSVData, text); } } } }
public void unzipFile(string archive_name) { // Open an existing zip file for reading ZipStorer zip = ZipStorer.Open(archive_name, FileAccess.Read); string local_filename = null; if (Path.GetExtension(archive_name) == ".zip") // remove .zip extention { local_filename = Path.GetFileName(archive_name.Substring(0, archive_name.Length - 4)); } // Read the central directory collection List <ZipStorer.ZipFileEntry> dir = zip.ReadCentralDir(); // Look for the desired file foreach (ZipStorer.ZipFileEntry entry in dir) { string zippedFilename = Path.GetFileName(entry.FilenameInZip); //Console.WriteLine("Unzip zippedFilename: {0}", zippedFilename); //Console.WriteLine("Unzip local_file: {0}", local_filename); if (!zippedFilename.Equals(local_filename, StringComparison.InvariantCultureIgnoreCase)) { Console.WriteLine("Unzip skipping file: {0}", zippedFilename); continue; } zip.ExtractFile(entry, Path.Combine(Path.GetDirectoryName(archive_name), zippedFilename)); if (zippedFilename == CFG_FILENAME) { Console.WriteLine("Reloading config file ..."); loadConfigFile(); } } zip.Dispose(); }
public static Action <List <XMindWriterContext> > ZipXMindFolder(string xmindFileName) { var xMindSettings = XMindConfigurationCache.Configuration.XMindConfigCollection; var filesToZipLabels = new string[] { "output:definition:meta", "output:definition:manifest", "output:definition:content" }; var fileNames = filesToZipLabels.Select(label => xMindSettings[label]).ToList(); var filesToZip = xMindSettings.GetSection("output:files") .GetChildren().Where( x => fileNames .Contains( x.GetChildren() .Where(el => el.Key == "name").Select(el => el.Value).FirstOrDefault() ) ) .Select(x => (File: x["name"], Path: x["location"])) .ToList(); return(ctx => { using (ZipStorer zip = ZipStorer.Create(Path.Combine(xMindSettings["output:base"], xmindFileName), string.Empty)) { foreach (var fileToken in filesToZip) { var fullPath = Path.Combine( Environment.CurrentDirectory, XMindConfigurationCache.Configuration.XMindConfigCollection["output:base"], fileToken.Path, fileToken.File ); zip.AddFile(ZipStorer.Compression.Deflate, fullPath, fileToken.File, string.Empty); } // zip.AddFile(ZipStorer.Compression.Deflate, "META-INF\\manifest.xml", "manifest.xml", string.Empty); // zip.AddFile(ZipStorer.Compression.Deflate, "meta.xml", "meta.xml", string.Empty); // zip.AddFile(ZipStorer.Compression.Deflate, "content.xml", "content.xml", string.Empty); } }); }
protected void btImport(object sender, EventArgs e) { try { if (!FileUpload1.HasFile) { return; } byte[] ba = FileUpload1.FileBytes; if (FileUpload1.FileName.ToLower().EndsWith(".zip")) { MemoryStream ms1 = new MemoryStream(ba); ZipStorer zip = ZipStorer.Open(ms1, FileAccess.Read); List <ZipStorer.ZipFileEntry> dir = zip.ReadCentralDir(); MemoryStream ms2 = new MemoryStream(); zip.ExtractFile(dir[0], ms2); zip.Close(); ba = ms2.ToArray(); } MemoryStream ms3 = new MemoryStream(ba); using (MySqlConnection conn = new MySqlConnection(txtConnString.Text)) { MySqlCommand cmd = new MySqlCommand(); MySqlBackup mb = new MySqlBackup(cmd); cmd.Connection = conn; conn.Open(); mb.ImportFromMemoryStream(ms3); } Header.Controls.Add(new LiteralControl("<script type=\"text/javascript\">alert('Import completed.');</script>")); } catch (Exception ex) { lbError.Text = ex.Message; lbError.Visible = true; } }
public static void ArchiveEpub(string srcDirName, string dstFileName) { var srcDir = new DirectoryInfo(srcDirName); var files = srcDir.EnumerateFiles(); //ファイルを取得 var dirs = srcDir.EnumerateDirectories(); //ディレクトリを取得 //mimetypeファイルを取得する var mimeTypeFile = files.FirstOrDefault(e => e.Name == "mimetype"); //container.xmlファイルを取得する var metaInfDir = dirs.First(e => e.Name == "META-INF"); var containedFiles = metaInfDir.EnumerateFiles(); var containerXmlFile = containedFiles.FirstOrDefault(e => e.Name == "container.xml"); if (mimeTypeFile == null) { MessageBox.Show("mimetypeファイルがありません"); } else if (containerXmlFile == null) { MessageBox.Show("container.xmlファイルがありません"); } else { //EPUBファイルを作成する using (ZipStorer zip = ZipStorer.Create(dstFileName, string.Empty)) { zip.EncodeUTF8 = true; //mimetypeファイルを書き込む 先頭・無圧縮 WriteFileToZip(zip, mimeTypeFile, "mimetype", ZipStorer.Compression.Store); //ディレクトリの内容を書き込む WriteDirToZip(zip, srcDir, string.Empty); } } }
protected override void Execute(CodeActivityContext context) { console = ActivityConsole.GetDefaultOrNew(context); hideConsoleOutput = SuppressConsoleOutput.Get(context); List <string> includePaths = IncludePaths.Get(context); string outputFile = OutputFile.Get(context); string comment = Comment.Get(context) ?? string.Empty; try { using (ZipStorer zipStorer = ZipStorer.Create(outputFile, comment)) { foreach (string includePath in includePaths) { FileAttributes attr = File.GetAttributes(includePath); DirectoryInfo directoryInfo = new DirectoryInfo(includePath); if ((attr & FileAttributes.Directory) == FileAttributes.Directory) { AddDirectory(zipStorer, directoryInfo, string.Empty, 0); } else { AddFile(zipStorer, includePath, directoryInfo.Name, string.Empty, 0); } } } } catch { try { File.Delete(outputFile); } catch { } throw; } }
public void FromStream( Stream sourceStream, IStorageService blobStorage, QueryBlobsReadFilterDelegate queryBlobsFilter) { using (var zipStorer = ZipStorer.Open(sourceStream, FileAccess.Read)) { IEnumerable <ZipStorer.ZipFileEntry> zipEntries = zipStorer.ReadCentralDir(); if (queryBlobsFilter != null) { zipEntries = zipEntries.Where(entry => { bool passed = true; queryBlobsFilter(entry.FilenameInZip, entry.FileSize, entry.ModifyTime, ref passed); return(passed); }); } // Copy data from zip stream to BLOBs foreach (var entry in zipEntries) { string fileName = Path.GetFileName(entry.FilenameInZip); // Skip if we have no filename if (string.IsNullOrEmpty(fileName)) { continue; } // Read zip entry and store it as BLOB using (var writeStream = new MemoryStream()) { zipStorer.ExtractFile(entry, writeStream); blobStorage.WriteStorage(entry.FilenameInZip, writeStream.ToArray()); } } } }
protected override void FlushCore() { // Ensure that all the data has been read out of the package // stream already. Otherwise we'll lose data when we recreate the zip foreach (ZipPackagePart part in Parts.Values) { part.GetStream(); } if (!PackageStream.CanSeek) { return; } // Empty the package stream PackageStream.Position = 0; PackageStream.SetLength(0); // Recreate the zip file using (ZipStorer archive = ZipStorer.Create(PackageStream, "", false)) { // Write all the part streams foreach (ZipPackagePart part in Parts.Values) { Stream partStream = part.GetStream(); partStream.Seek(0, SeekOrigin.Begin); archive.AddStream(ZipStorer.Compression.Deflate, part.Uri.ToString().Substring(1), partStream, DateTime.UtcNow, ""); } using (var ms = new MemoryStream()) { WriteContentType(ms); ms.Seek(0, SeekOrigin.Begin); archive.AddStream(ZipStorer.Compression.Deflate, ContentUri, ms, DateTime.UtcNow, ""); } } }
bool SelfUpdate() { label1.Text = "Updating updater =)"; string oldUpdater = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, AppDomain.CurrentDomain.FriendlyName); ZipStorer.ZipFileEntry updater; try { updater = (from entry in updatePackageCatalog where entry.FilenameInZip == AppDomain.CurrentDomain.FriendlyName select entry).Single(); } catch (InvalidOperationException exc) { return(false); } if (ZipStorer.CalculateCrc32(oldUpdater) != updater.Crc32) { File.Move(oldUpdater, String.Format("{0}.tmp", oldUpdater)); return(updatePackage.ExtractFile(updater, oldUpdater));; } return(false); }
public static void ExtractNativeBinary(Stream resourceStream, string destPath) { var zipStream = resourceStream; // using ZipStorer (nuget pkg) here instead of ZipArchive (.NET built in) because older versions of mono don't support it using (var zip = ZipStorer.Open(zipStream, FileAccess.Read)) { string nativeCodeFilename = $"native_code_{GetCurrentPlatform().ToFriendlyString().ToLower()}_{GetArchString()}"; foreach (var entry in zip.ReadCentralDir()) { if (entry.FilenameInZip == nativeCodeFilename) { using (var f = File.OpenWrite(destPath)) zip.ExtractFile(entry, f); return; } } throw new PlatformNotSupportedException("This package does not contain native code for your platform"); } }
public static PersonContainer ParseFromFile() { var zipFilePath = Path.Combine(Environment.CurrentDirectory, "Resources", ZipFileName); using (var zipStorer = ZipStorer.Open(zipFilePath, FileAccess.Read)) { var zipDir = zipStorer.ReadCentralDir(); foreach (var zipEntry in zipDir) { if (Path.GetFileName(zipEntry.FilenameInZip) == JsonFileName) { using (var ms = new MemoryStream()) { zipStorer.ExtractFile(zipEntry, ms); var json = Encoding.UTF8.GetString(ms.ToArray()); return(JsonConvert.DeserializeObject <PersonContainer>(json)); } } } return(null); } }
/// <summary> /// zip压缩 /// </summary> /// <param name="paths">文件绝对路径</param> /// <param name="zipPath">zip文件绝对路径</param> /// <returns>是否压缩成功</returns> public static bool CreateZip(List <string> paths, string zipPath) { using (ZipStorer zip = ZipStorer.Create(zipPath, string.Empty)) { List <Tuple <string, string> > exPathWithRels = new List <Tuple <string, string> >(); //绝对路径 zip中的相对路径 foreach (string path in paths) { //参数中所有路径 if (File.Exists(path)) { //文件 zip.AddFile(ZipStorer.Compression.Deflate, path, Path.GetFileName(path), string.Empty); } else if (Directory.Exists(path)) { //文件夹 int pathLength = Path.GetDirectoryName(path).Length; //获取目录长度 List <string> exPaths = TPath.GetFilePaths(path); //获取文件夹中所有文件 包含子目录中文件 foreach (string exPath in exPaths) { exPathWithRels.Add(Tuple.Create(exPath, exPath.Remove(0, pathLength))); } } else { throw new InvalidOperationException("路径非法:" + path); } } foreach (var path in exPathWithRels) { if (File.Exists(path.Item1)) { //文件夹中文件路径 zip.AddFile(ZipStorer.Compression.Deflate, path.Item1, path.Item2, string.Empty); } else { throw new InvalidOperationException("路径非法:" + path); } } } return(true); }
static ArchiveExtractor() { RegisterExtractor(stream => { var archive = ZipStorer.Open(stream, FileAccess.Read); var root = Folder.Root; foreach (var entry in archive.ReadCentralDir()) { if (!entry.FilenameInZip.EndsWith("/")) { var ms = new MemoryStream(); archive.ExtractFile(entry, ms); ms.Position = 0; root.PathAddFile(entry.FilenameInZip, FileData.FromStream(ms)); } } return(root); }); }
internal static OpfPackage CreatePackage(XElement element, ZipStorer gz, string opsFolder, out string ncx) { var package = new OpfPackage { Version = element.Attribute("version").Value, Identifier = element.Attribute("unique-identifier").Value, MetaData = MetaData.CreateMetaData(element.Element(OpfNameSpace + "metadata")), Spine = Spine.CreateSpine(element.Element(OpfNameSpace + "spine")) }; var manifestElement = element.Element(OpfNameSpace + "manifest"); var ncxElement = package.Spine.Toc; // we need to pull it directly from XML as this file does not become part of the items ncx = manifestElement .Elements(OpfNameSpace + "item") .First(item => item.Attribute("id").Value == ncxElement) .Attribute("href") .Value; package.Manifest = Manifest.CreateManifest(gz, manifestElement, ncxElement, opsFolder); package.Guide = Guide.CreateGuide(element); return(package); }
//Epubにファイルを追加する(mimetypeを除く) private static void WriteEpubFilesToZip(ZipStorer zip, string srcDir) { var files = Directory.GetFiles(srcDir, "*", SearchOption.AllDirectories); //全ファイル var targetFiles = files.Where(e => Path.GetFileName(e).Equals("mimetype") != true) //mimetypeを除く .Select(e => new FileInfo(e)); foreach (var targetFile in targetFiles) { var ext = targetFile.Extension; var compression = new ZipStorer.Compression(); switch (ext) { case "jpg": //画像ファイルは圧縮しない(時間の無駄なので) case "JPEG": case "png": case "PNG": case "gif": case "GIF": compression = ZipStorer.Compression.Store; break; case "EPUB": case "epub": continue; //EPUBファイルは格納しない default: compression = ZipStorer.Compression.Deflate; //通常のファイルは圧縮する break; } //対象を書き込む using (var ms = new MemoryStream(File.ReadAllBytes(targetFile.FullName))) { ms.Position = 0; //ファイルの先頭からコピー var fileNameInZip = GetRelPath(targetFile.FullName, srcDir); //zip内でのファイル名 zip.AddStream(compression, fileNameInZip, ms, DateTime.Now, string.Empty); } } }
private bool DownloadAndExtractNewTempFiles() { var data = _webClient.DownloadData(_downloadUrl); using (var archive = ZipStorer.Open(new MemoryStream(data), FileAccess.Read)) { var entries = archive.ReadCentralDir(); var extractOps = _fileOps.FindAll(o => o.Operation == FileOperationType.ExtractFile); foreach (var op in extractOps) { var entryIdx = entries.FindIndex(e => e.FilenameInZip == op.FilePath); if (entryIdx < 0) { if (op.AllowedToFail) { continue; } else { return(false); } } var entry = entries[entryIdx]; var success = archive.ExtractFile(entry, op.FilePath + UpdaterHelper.NewFileExtension); if (success) { AddUndoDelete(op.FilePath + UpdaterHelper.NewFileExtension); } else if (!success && !op.AllowedToFail) { return(false); } } } return(true); }
public static void Run(Uri url, Guid GUID, ZipStorer Stage) { var engine = Engines.IronPython.CreateEngine(); using (MemoryStream engineStream = new MemoryStream()) { engine.Runtime.IO.SetOutput(engineStream, Encoding.UTF8); engine.Runtime.IO.SetErrorOutput(engineStream, Encoding.UTF8); var scope = engine.CreateScope(); scope.SetVariable("URL", url); scope.SetVariable("GUID", GUID); scope.SetVariable("IronPythonDLL", Assembly.Load(Internals.GetResourceInZip(Stage, "IronPython.dll"))); #if DEBUG scope.SetVariable("DEBUG", true); #elif RELEASE scope.SetVariable("DEBUG", false); #endif byte[] mainPyFile = Internals.GetResourceInZip(Stage, "Main.py"); engine.Execute(Encoding.UTF8.GetString(mainPyFile, 0, mainPyFile.Length), scope); } }
public string ToBase64String() { string result = string.Empty; this.WriteToDisk(); using (MemoryStream memoryStream = new MemoryStream()) { using (ZipStorer zipStorer = ZipStorer.Create(memoryStream, string.Empty)) { string[] files = Directory.GetFiles(this.profileDir, "*.*", SearchOption.AllDirectories); string[] array = files; for (int i = 0; i < array.Length; i++) { string text = array[i]; string fileNameInZip = text.Substring(this.profileDir.Length).Replace(Path.DirectorySeparatorChar, '/'); zipStorer.AddFile(ZipStorer.CompressionMethod.Deflate, text, fileNameInZip, string.Empty); } } result = Convert.ToBase64String(memoryStream.ToArray()); this.Clean(); } return(result); }
private void ButtonBrowse4_Click(object sender, EventArgs e) { OpenFileDialog dlg = new OpenFileDialog(); dlg.AddExtension = true; dlg.CheckFileExists = true; dlg.Multiselect = false; dlg.Title = "Select storage file"; if (dlg.ShowDialog() == DialogResult.OK) { TextStorage4.Text = dlg.FileName; // Opens existing zip file ZipStorer zip = ZipStorer.Open(TextStorage4.Text, FileAccess.Read); // Read all directory contents List <ZipStorer.ZipFileEntry> dir = zip.ReadCentralDir(); listBox4.Tag = zip; // keep the zipstorer alive listBox4.DataSource = dir; } }
static string ReadMassiveRemoteZipFileButJavaCodeOnly(string url) { HighTimeoutWebclient wc = new HighTimeoutWebclient(); wc.Encoding = UTF8; byte[] received = null; try { received = wc.DownloadData(url); } catch (Exception ex) { Logger.Output(LogType.ERROR, "Failed to read MassiveRemoteZip: " + ex.ToString() + " for " + url); return(""); } wc.Dispose(); MemoryStream ms = new MemoryStream(received); Logger.Output(LogType.DEBUG, "Received " + received.Length + " bytes to parse from <" + url + ">..."); ZipStorer zs = ZipStorer.Open(ms, FileAccess.Read); StringBuilder toret = new StringBuilder(); foreach (ZipStorer.ZipFileEntry zfe in zs.ReadCentralDir()) { if (zfe.FilenameInZip.Contains(".java")) { MemoryStream mes = new MemoryStream(); zs.ExtractFile(zfe, mes); byte[] bytes = mes.ToArray(); mes.Close(); toret.Append("/<FILE:" + zfe.FilenameInZip + "\n"); toret.Append(UTF8.GetString(bytes)); } } ms.Close(); return(toret.ToString()); }
/// <summary> /// Removes one of many files in storage. It creates a new Zip file. /// </summary> /// <param name="_zip"> /// Reference to the current Zip object /// </param> /// <param name="_zfes"> /// List of Entries to remove from storage /// </param> /// <returns> /// True if success, false if not /// </returns> /// <remarks> /// This method only works for storage of type FileStream /// </remarks> public static bool RemoveEntries(ref ZipStorer _zip, List<ZipFileEntry> _zfes) { if (!(_zip.ZipFileStream is FileStream)) { throw new InvalidOperationException("RemoveEntries is allowed just over streams of type FileStream"); } // Get full list of entries List<ZipFileEntry> fullList = _zip.ReadCentralDir(); // In order to delete we need to create a copy of the zip file excluding the selected items string tempZipName = Path.GetTempFileName(); string tempEntryName = Path.GetTempFileName(); try { ZipStorer tempZip = Create(tempZipName, string.Empty); foreach (ZipFileEntry zfe in fullList) { if (!_zfes.Contains(zfe)) { if (_zip.ExtractFile(zfe, tempEntryName)) { tempZip.AddFile(zfe.Method, tempEntryName, zfe.FilenameInZip, zfe.Comment); } } } _zip.Close(); tempZip.Close(); File.Delete(_zip.FileName); File.Move(tempZipName, _zip.FileName); _zip = Open(_zip.FileName, _zip.Access); } catch { return false; } finally { if (File.Exists(tempZipName)) { File.Delete(tempZipName); } if (File.Exists(tempEntryName)) { File.Delete(tempEntryName); } } return true; }
/// <summary> /// Method to open an existing storage from stream /// </summary> /// <param name="_stream">Already opened stream with zip contents</param> /// <param name="_access">File access mode for stream operations</param> /// <returns>A valid ZipStorer object</returns> public static ZipStorer Open(Stream _stream, FileAccess _access, bool _ownsStream = false) { if (!_stream.CanSeek && _access != FileAccess.Read) throw new InvalidOperationException("Stream cannot seek"); ZipStorer zip = new ZipStorer(); //zip.FileName = _filename; zip.ZipFileStream = _stream; zip.OwnsStream = _ownsStream; zip.Access = _access; if (zip.ReadFileInfo()) return zip; throw new System.IO.InvalidDataException(); }
/// <summary> /// Method to create a new zip storage in a stream /// </summary> /// <param name="_stream"> /// </param> /// <param name="_comment"> /// </param> /// <returns> /// A valid ZipStorer object /// </returns> public static ZipStorer Create(Stream _stream, string _comment) { var zip = new ZipStorer(); zip.Comment = _comment; zip.ZipFileStream = _stream; zip.Access = FileAccess.Write; return zip; }
/// <summary> /// Method to open an existing storage from stream /// </summary> /// <param name="_stream"> /// Already opened stream with zip contents /// </param> /// <param name="_access"> /// File access mode for stream operations /// </param> /// <returns> /// A valid ZipStorer object /// </returns> public static ZipStorer Open(Stream _stream, FileAccess _access) { if (!_stream.CanSeek && _access != FileAccess.Read) { throw new InvalidOperationException("Stream cannot seek"); } var zip = new ZipStorer(); // zip.FileName = _filename; zip.ZipFileStream = _stream; zip.Access = _access; if (zip.ReadFileInfo()) { return zip; } throw new InvalidDataException(); }
/// <summary> /// Method to open an existing storage from stream /// </summary> /// <param name="_stream">Already opened stream with zip contents</param> /// <param name="_access">File access mode for stream operations</param> /// <returns>A valid ZipStorer object</returns> private static ZipStorer Open(Stream _stream, FileAccess _access) { if (!_stream.CanSeek && _access != FileAccess.Read) throw new InvalidOperationException("Stream cannot seek"); var zip = new ZipStorer {ZipFileStream = _stream, Access = _access}; //zip.FileName = _filename; if (zip.ReadFileInfo()) return zip; throw new InvalidDataException(); }
/// <summary> /// Method to create a new zip storage in a stream /// </summary> /// <param name="_stream"></param> /// <param name="_comment"></param> /// <returns>A valid ZipStorer object</returns> private static ZipStorer Create(Stream _stream, string _comment) { var zip = new ZipStorer {Comment = _comment, ZipFileStream = _stream, Access = FileAccess.Write}; return zip; }
internal ZipStorer zip = null; // The zip storer holding the main XLSX file stream #endregion Fields #region Constructors // Constructor from a file name public OoXml(string template_filename) { zip = ZipStorer.Open(template_filename, FileAccess.Read); // Open the template foreach (ZipStorer.ZipFileEntry l in zip.ReadCentralDir()) streams.Add(new gStream(this, zip, l)); // Get the streams that make up the template and add them SetStructure(); // Analyzes the Sheets structure }
/// <summary> /// Method to create a new zip storage in a stream /// </summary> /// <param name="stream"></param> /// <param name="comment"></param> /// <returns>A valid ZipStorer object</returns> public static ZipStorer Create(Stream stream, string comment) { var zip = new ZipStorer {_comment = comment, _zipFileStream = stream, _access = FileAccess.Write}; return zip; }
/// <summary> /// Method to create a new zip storage in a stream /// </summary> /// <param name="_stream"></param> /// <param name="_comment"></param> /// <returns>A valid ZipStorer object</returns> public static ZipStorer Create(Stream _stream, string _comment, bool _ownsStream = false) { ZipStorer zip = new ZipStorer(); zip.Comment = _comment; zip.ZipFileStream = _stream; zip.OwnsStream = _ownsStream; zip.Access = FileAccess.Write; return zip; }
/// <summary> /// Method to open an existing storage from stream /// </summary> /// <param name="stream">Already opened stream with zip contents</param> /// <param name="access">File access mode for stream operations</param> /// <returns>A valid ZipStorer object</returns> public static ZipStorer Open(Stream stream, FileAccess access) { if (!stream.CanSeek && access != FileAccess.Read) throw new InvalidOperationException("Stream cannot seek"); var zip = new ZipStorer {_zipFileStream = stream, _access = access}; if (zip.ReadFileInfo()) return zip; throw new InvalidDataException(); }
internal ZipStorer.ZipFileEntry zfe; // This is the ZipFileEntry where the stream is stored #endregion Fields #region Constructors // This constructor is called when creating the stream from the source template public gStream(OoXml doc, ZipStorer zip, ZipStorer.ZipFileEntry z) { Document = doc; // Save a reference to the document zfe = z; // Store the ZipFileEntry }
public static void AddText( this ZipStorer self, ZipStorer.Compression _method, string _text, string _filenameInZip, DateTime _modTime, string _comment ) { byte[] bytes = Encoding.UTF8.GetBytes( _text ); MemoryStream stream = new MemoryStream( bytes ); self.AddStream( _method, _filenameInZip, stream, _modTime, _comment ); }
// Close the excel file public void Close() { if (zip != null) { zip.Close(); zip = null; } }