// File : Create new, Append to existing, Raz existing // ArchiveType : Rar = 0, Zip = 1, Tar = 2, SevenZip = 3, GZip = 4 // CompressionType : None = 0, GZip = 1, BZip2 = 2, PPMd = 3, Deflate = 4, Rar = 5, LZMA = 6, BCJ = 7, BCJ2 = 8, Unknown = 9, // Zip compression type : BZip2 // GZip compression type : GZip // example from https://github.com/adamhathcock/sharpcompress/wiki/API-Examples // this example dont work to add file to an existing zip public static void Test_Compress(string compressFile, IEnumerable<string> files, string baseDirectory = null, ArchiveType archiveType = ArchiveType.Zip, CompressionType compressionType = CompressionType.BZip2, CompressionLevel compressionLevel = CompressionLevel.Default) { //FileOption if (baseDirectory != null && !baseDirectory.EndsWith("\\")) baseDirectory = baseDirectory + "\\"; CompressionInfo compressionInfo = new CompressionInfo(); compressionInfo.DeflateCompressionLevel = compressionLevel; compressionInfo.Type = compressionType; //Trace.WriteLine("SharpCompressManager : DeflateCompressionLevel {0}", compressionInfo.DeflateCompressionLevel); //Trace.WriteLine("SharpCompressManager : CompressionType {0}", compressionInfo.Type); Trace.WriteLine($"open compressed file \"{compressFile}\""); // File.OpenWrite ==> OpenOrCreate using (FileStream stream = File.OpenWrite(compressFile)) using (IWriter writer = WriterFactory.Open(stream, archiveType, compressionInfo)) //using (IWriter writer = WriterFactory.Open(stream, archiveType, CompressionType.BZip2)) { foreach (string file in files) { string entryPath; if (baseDirectory != null && file.StartsWith(baseDirectory)) entryPath = file.Substring(baseDirectory.Length); else entryPath = zPath.GetFileName(file); Trace.WriteLine($"add file \"{entryPath}\" \"{file}\""); writer.Write(entryPath, file); } } }
public static IWriter Open(Stream stream, ArchiveType archiveType, CompressionInfo compressionInfo) { switch (archiveType) { case ArchiveType.GZip: { if (compressionInfo.Type != CompressionType.GZip) { throw new InvalidFormatException("GZip archives only support GZip compression type."); } return new GZipWriter(stream); } case ArchiveType.Zip: { return new ZipWriter(stream, compressionInfo, null); } case ArchiveType.Tar: { return new TarWriter(stream, compressionInfo); } default: { throw new NotSupportedException("Archive Type does not have a Writer: " + archiveType); } } }
public ZipCompressionInfo(CompressionInfo compressionInfo) { switch (compressionInfo.Type) { case CompressionType.None: this.Compression = ZipCompressionMethod.None; return; case CompressionType.BZip2: this.Compression = ZipCompressionMethod.BZip2; return; case CompressionType.PPMd: this.Compression = ZipCompressionMethod.PPMd; return; case CompressionType.Deflate: this.DeflateCompressionLevel = compressionInfo.DeflateCompressionLevel; this.Compression = ZipCompressionMethod.Deflate; return; case CompressionType.LZMA: this.Compression = ZipCompressionMethod.LZMA; return; } throw new InvalidFormatException("Invalid compression method: " + compressionInfo.Type); }
public void Write(string entryPath, Stream source, DateTime? modificationTime, string comment, CompressionInfo compressionInfo = null) { using (Stream output = WriteToStream(entryPath, modificationTime, comment, compressionInfo)) { source.TransferTo(output); } }
/// <summary> /// Create an archive from a directory. It will iterate through all directories recursively. /// </summary> /// <param name="folderPath">Folder/directory to archive</param> /// <param name="outputFile">Ouput path, including file name, of the resulting archive</param> /// <param name="useZip">true for zip format; false for tar.gz format</param> public static void CreateArchive(string folderPath, string outputFile, bool useZip) { using (var outputStream = File.OpenWrite(outputFile)) { ArchiveType atype; var cinfo = new CompressionInfo(); if (useZip) { atype = ArchiveType.Zip; cinfo.Type = CompressionType.Deflate; cinfo.DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.Default; } else { atype = ArchiveType.Tar; cinfo.Type = CompressionType.GZip; cinfo.DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.Default; } using (var awriter = WriterFactory.Open(outputStream, atype, cinfo)) { awriter.WriteAll(folderPath, "*", SearchOption.AllDirectories); } } }
public ZipCompressionInfo(CompressionInfo compressionInfo) { switch (compressionInfo.Type) { case CompressionType.None: { this.Compression = ZipCompressionMethod.None; } break; case CompressionType.Deflate: { this.DeflateCompressionLevel = compressionInfo.DeflateCompressionLevel; this.Compression = ZipCompressionMethod.Deflate; } break; case CompressionType.BZip2: { this.Compression = ZipCompressionMethod.BZip2; } break; case CompressionType.LZMA: { this.Compression = ZipCompressionMethod.LZMA; } break; case CompressionType.PPMd: { this.Compression = ZipCompressionMethod.PPMd; } break; default: throw new InvalidFormatException("Invalid compression method: " + compressionInfo.Type); } }
public TarWriter(Stream destination, CompressionInfo compressionInfo) : base(ArchiveType.Tar) { if (!destination.CanWrite) { throw new ArgumentException("Tars require writable streams."); } switch (compressionInfo.Type) { case CompressionType.None: break; case CompressionType.BZip2: { destination = new BZip2Stream(destination, CompressionMode.Compress, false); } break; case CompressionType.GZip: { destination = new GZipStream(destination, CompressionMode.Compress, false); } break; default: { throw new InvalidFormatException("Tar does not support compression: " + compressionInfo.Type); } } InitalizeStream(destination, false); }
public void Write(string entryPath, Stream source, DateTime? modificationTime, string comment, CompressionInfo compressionInfo) { using (Stream stream = this.WriteToStream(entryPath, modificationTime, comment, compressionInfo)) { Utility.TransferTo(source, stream); } }
public static void CreateZip(string path, string sourceFileFolder, string comment) { if (!string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(sourceFileFolder)) { SharpCompress.Common.CompressionInfo ci = new SharpCompress.Common.CompressionInfo(); ci.DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.BestCompression; using (FileStream sw = new FileStream(path, FileMode.Create, FileAccess.Write)) { SharpCompress.Writer.Zip.ZipWriter zw = new SharpCompress.Writer.Zip.ZipWriter(sw, ci, comment); DirectoryInfo dir = new DirectoryInfo(sourceFileFolder); foreach (FileInfo f in dir.GetFiles("*.*", SearchOption.AllDirectories)) { using (FileStream fs = f.OpenRead()) { string relativePath = string.Empty; if (f.FullName.Length > sourceFileFolder.Length) { relativePath = f.FullName.Substring(sourceFileFolder.Length + 1); } zw.Write(relativePath, fs, f.LastWriteTime); } } } } }
public static void SaveTo(this IWritableArchive writableArchive, FileInfo fileInfo, CompressionInfo compressionInfo) { using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write)) { writableArchive.SaveTo(stream, compressionInfo); } }
public ZipWriter(Stream destination, CompressionInfo compressionInfo, string zipComment) : base(ArchiveType.Zip) { this.zipComment = zipComment ?? string.Empty; this.zipCompressionInfo = new ZipCompressionInfo(compressionInfo); InitalizeStream(destination, false); }
public ZipWriter(Stream destination, CompressionInfo compressionInfo, string zipComment) : base(ArchiveType.Zip) { this.ppmdProperties = new PpmdProperties(); this.entries = new List<ZipCentralDirectoryEntry>(); this.zipComment = zipComment ?? string.Empty; this.zipCompressionInfo = new ZipCompressionInfo(compressionInfo); base.InitalizeStream(destination, false); }
public Stream WriteToStream(string entryPath, DateTime? modificationTime, string comment, CompressionInfo compressionInfo) { entryPath = this.NormalizeFilename(entryPath); DateTime? nullable = modificationTime; modificationTime = new DateTime?(nullable.HasValue ? nullable.GetValueOrDefault() : DateTime.Now); comment = comment ?? ""; ZipCentralDirectoryEntry entry2 = new ZipCentralDirectoryEntry(); entry2.Comment = comment; entry2.FileName = entryPath; entry2.ModificationTime = modificationTime; entry2.HeaderOffset = (uint) this.streamPosition; ZipCentralDirectoryEntry entry = entry2; uint num = (uint) this.WriteHeader(entryPath, modificationTime, compressionInfo); this.streamPosition += num; return new ZipWritingStream(this, base.OutputStream, entry); }
public Stream WriteToStream(string entryPath, DateTime? modificationTime, string comment, CompressionInfo compressionInfo = null) { entryPath = NormalizeFilename(entryPath); modificationTime = modificationTime ?? DateTime.Now; comment = comment ?? ""; var entry = new ZipCentralDirectoryEntry { Comment = comment, FileName = entryPath, ModificationTime = modificationTime, HeaderOffset = (uint) streamPosition, }; var headersize = (uint)WriteHeader(entryPath, modificationTime, compressionInfo); streamPosition += headersize; return new ZipWritingStream(this, OutputStream, entry, compressionInfo); }
private readonly PpmdProperties ppmdProperties; // Caching properties to speed up PPMd. #endif public ZipWriter(Stream destination, CompressionInfo compressionInfo, string zipComment, Encoding encoding = null) : base(ArchiveType.Zip) { this.zipComment = zipComment ?? string.Empty; this.encoding = encoding ?? ArchiveEncoding.Default; switch (compressionInfo.Type) { case CompressionType.None: { compression = ZipCompressionMethod.None; } break; case CompressionType.Deflate: { compression = ZipCompressionMethod.Deflate; deflateCompressionLevel = compressionInfo.DeflateCompressionLevel; } break; case CompressionType.BZip2: { compression = ZipCompressionMethod.BZip2; } break; #if LZMA case CompressionType.LZMA: { compression = ZipCompressionMethod.LZMA; } break; #endif #if PPMd case CompressionType.PPMd: { ppmdProperties = new PpmdProperties(); compression = ZipCompressionMethod.PPMd; } break; #endif default: throw new InvalidFormatException("Invalid compression method: " + compressionInfo.Type); } InitalizeStream(destination, false); }
/// <summary> /// /// </summary> /// <param name="strBasePath">要压缩文件所在文件夹</param> /// <param name="strSourceFolderName">生成TAR包存放路径</param> /// <param name="sTarName">TAR包名</param> /// <returns></returns> public bool CreatTar(string strBasePath, string strSourceFolderName, string sTarName) { if (!System.IO.Directory.Exists(strSourceFolderName)) { System.IO.Directory.CreateDirectory(strSourceFolderName);//不存在生成Tar文件目录就创建 } if (string.IsNullOrEmpty(strBasePath) || string.IsNullOrEmpty(strSourceFolderName) || !System.IO.Directory.Exists(strBasePath)) //Path.Combine(strBasePath, strSourceFolderName) { return(false); } string strOupFileAllPath = strSourceFolderName + "\\EBDT_" + sTarName + ".tar";//压缩文件名及路径 Stream outStream = new FileStream(strOupFileAllPath, FileMode.OpenOrCreate); SharpCompress.Archive.Tar.TarArchive archive = SharpCompress.Archive.Tar.TarArchive.Create(); try { DirectoryInfo theFolder = new DirectoryInfo(strBasePath); FileInfo[] xmlfiles = theFolder.GetFiles("*.xml"); if (xmlfiles.Length > 0) { for (int i = 0; i < xmlfiles.Length; i++) { archive.AddEntry(xmlfiles[i].Name, xmlfiles[i]); } SharpCompress.Common.CompressionInfo infs = new SharpCompress.Common.CompressionInfo(); archive.SaveTo(outStream, infs); outStream.Close(); archive.Dispose(); } else { return(false); } } catch { //outStream.Close(); return(false); } return(true); }
private async void OnlineBackupExecute(string path) { await Task.Factory.StartNew(() => { var zipFilePath = string.Empty; try { IsEnable = false; IsIndeterminate = true; path = DatabaseBackup(); zipFilePath = path.Replace("bak", "zip"); var info = new CompressionInfo {Type = CompressionType.Deflate}; using (FileStream zip = File.OpenWrite(zipFilePath)) using (IWriter zipwriter = WriterFactory.Open(zip, ArchiveType.Zip, info)) { zipwriter.Write(Path.GetFileName(path), path); } GetDropBoxAccess(); IsIndeterminate = false; ICloudDirectoryEntry uploadFolder = _dropBoxStorage.GetFolder("/DatabaseTransfar"); _dropBoxStorage.UploadFile(zipFilePath, uploadFolder, UploadProgressChange); MessageBox.Show("Online Database Backup Successfully", SoftwareName, MessageBoxButton.OK, MessageBoxImage.Information); } catch (Exception) { MessageBox.Show("Online Database Backup is canceled", SoftwareName, MessageBoxButton.OK, MessageBoxImage.Exclamation); ResetData(); } finally { IsIndeterminate = true; if (_dropBoxStorage.IsOpened) _dropBoxStorage.Close(); if (File.Exists(path)) File.Delete(path); if(!String.IsNullOrEmpty(zipFilePath) && File.Exists(zipFilePath)) File.Delete(zipFilePath); IsEnable = true; IsIndeterminate = false; } }); }
/// <summary> /// Constructs a new zip instance. /// If the file exists and has a non-zero length we read it, /// otherwise we create a new archive. /// </summary> /// <param name="filename">The name of the file to read or write</param> /// <param name="options">The options passed on the commandline</param> public FileArchiveZip(string filename, Dictionary<string, string> options) { if (string.IsNullOrEmpty(filename) && filename.Trim().Length == 0) throw new ArgumentException("filename"); if (File.Exists(filename) && new FileInfo(filename).Length > 0) { m_isWriting = false; m_filename = filename; } else { m_compressionInfo = new CompressionInfo(); m_compressionInfo.Type = DEFAULT_COMPRESSION_METHOD; m_compressionInfo.DeflateCompressionLevel = DEFAULT_COMPRESSION_LEVEL; string cpmethod; CompressionType tmptype; if (options.TryGetValue(COMPRESSION_METHOD_OPTION, out cpmethod) && Enum.TryParse<SharpCompress.Common.CompressionType>(cpmethod, true, out tmptype)) m_compressionInfo.Type = tmptype; string cplvl; int tmplvl; if (options.TryGetValue(COMPRESSION_LEVEL_OPTION, out cplvl) && int.TryParse(cplvl, out tmplvl)) m_compressionInfo.DeflateCompressionLevel = (SharpCompress.Compressor.Deflate.CompressionLevel)Math.Max(Math.Min(9, tmplvl), 0); else if (options.TryGetValue(COMPRESSION_LEVEL_OPTION_ALIAS, out cplvl) && int.TryParse(cplvl, out tmplvl)) m_compressionInfo.DeflateCompressionLevel = (SharpCompress.Compressor.Deflate.CompressionLevel)Math.Max(Math.Min(9, tmplvl), 0); m_defaultCompressionLevel = m_compressionInfo.DeflateCompressionLevel; m_isWriting = true; m_stream = new System.IO.FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.Read); m_writer = WriterFactory.Open(m_stream, ArchiveType.Zip, m_compressionInfo); //Size of endheader, taken from SharpCompress ZipWriter m_flushBufferSize = 8 + 2 + 2 + 4 + 4 + 2 + 0; } }
public static IWriter Open(Stream stream, ArchiveType archiveType, CompressionType compressionType) { CompressionInfo compressionInfo = new CompressionInfo(); compressionInfo.Type = compressionType; return Open(stream, archiveType, compressionInfo); }
public static void SaveTo(this IWritableArchive writableArchive, string filePath, CompressionInfo compressionInfo) { writableArchive.SaveTo(new FileInfo(filePath), compressionInfo); }
public static void SaveTo(IWritableArchive writableArchive, Stream stream, CompressionType compressionType) { CompressionInfo info = new CompressionInfo(); info.Type = compressionType; writableArchive.SaveTo(stream, info); }
private int WriteHeader(string filename, DateTime? modificationTime, CompressionInfo compressionInfo) { ZipCompressionInfo info = (compressionInfo != null) ? new ZipCompressionInfo(compressionInfo) : this.zipCompressionInfo; byte[] bytes = ArchiveEncoding.Default.GetBytes(filename); base.OutputStream.Write(BitConverter.GetBytes((uint) 0x4034b50), 0, 4); byte[] buffer = new byte[2]; buffer[0] = 0x3f; base.OutputStream.Write(buffer, 0, 2); HeaderFlags flags = (ArchiveEncoding.Default == Encoding.UTF8) ? HeaderFlags.UTF8 : ((HeaderFlags) 0); if (!base.OutputStream.CanSeek) { flags = (HeaderFlags) ((ushort) (flags | HeaderFlags.UsePostDataDescriptor)); if (info.Compression == ZipCompressionMethod.LZMA) { flags = (HeaderFlags) ((ushort) (flags | HeaderFlags.Bit1)); } } base.OutputStream.Write(BitConverter.GetBytes((ushort) flags), 0, 2); base.OutputStream.Write(BitConverter.GetBytes((ushort) info.Compression), 0, 2); base.OutputStream.Write(BitConverter.GetBytes(Utility.DateTimeToDosTime(modificationTime)), 0, 4); buffer = new byte[12]; base.OutputStream.Write(buffer, 0, 12); base.OutputStream.Write(BitConverter.GetBytes((ushort) bytes.Length), 0, 2); base.OutputStream.Write(BitConverter.GetBytes((ushort) 0), 0, 2); base.OutputStream.Write(bytes, 0, bytes.Length); return (30 + bytes.Length); }
private int WriteHeader(string filename, DateTime? modificationTime, CompressionInfo compressionInfo = null) { var explicitZipCompressionInfo = compressionInfo != null ? new ZipCompressionInfo(compressionInfo) : this.zipCompressionInfo; byte[] encodedFilename = ArchiveEncoding.Default.GetBytes(filename); OutputStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4); if (explicitZipCompressionInfo.Compression == ZipCompressionMethod.Deflate) { OutputStream.Write(new byte[] {20, 0}, 0, 2); //older version which is more compatible } else { OutputStream.Write(new byte[] {63, 0}, 0, 2); //version says we used PPMd or LZMA } HeaderFlags flags = ArchiveEncoding.Default == Encoding.UTF8 ? HeaderFlags.UTF8 : (HeaderFlags)0; if (!OutputStream.CanSeek) { flags |= HeaderFlags.UsePostDataDescriptor; if (explicitZipCompressionInfo.Compression == ZipCompressionMethod.LZMA) { flags |= HeaderFlags.Bit1; // eos marker } } OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) flags), 0, 2); OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)explicitZipCompressionInfo.Compression), 0, 2); // zipping method OutputStream.Write(DataConverter.LittleEndian.GetBytes(modificationTime.DateTimeToDosTime()), 0, 4); // zipping date and time OutputStream.Write(new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 12); // unused CRC, un/compressed size, updated later OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) encodedFilename.Length), 0, 2); // filename length OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) 0), 0, 2); // extra length OutputStream.Write(encodedFilename, 0, encodedFilename.Length); return 6 + 2 + 2 + 4 + 12 + 2 + 2 + encodedFilename.Length; }
internal ZipWritingStream(ZipWriter writer, Stream originalStream, ZipCentralDirectoryEntry entry, CompressionInfo compressionInfo) { this.writer = writer; this.originalStream = originalStream; this.writer = writer; this.entry = entry; this.compressionInfo = compressionInfo == null ? writer.zipCompressionInfo : new ZipCompressionInfo(compressionInfo); writeStream = GetWriteStream(originalStream); }