/// <summary> /// self compress a folder to a content /// </summary> /// <param name="outputFileName"></param> /// <param name="inputFolder"></param> /// <param name="resultCount"></param> /// <returns></returns> public bool CompressFolder(string outputFileName, string inputFolder, out int resultCount) { SevenZip.SevenZipCompressor cp = null; try { cp = new SevenZip.SevenZipCompressor(); cp.ArchiveFormat = SevenZip.OutArchiveFormat.Zip; string[] outputFiles = new DirectoryInfo(inputFolder).GetFiles("*.*").Select(p => p.FullName).ToArray(); using (FileStream fs = new FileStream(outputFileName, FileMode.Create)) { cp.CompressFiles(fs, outputFiles); } resultCount = outputFiles.Count(); return(true); } catch (Exception err) { resultCount = 0; return(false); } finally { cp = null; } }
public static byte[] CreateWrappedArchive(string basePath, string[] includes, string[] excludes) { using (MemoryStream inStream = new MemoryStream()) { var zipOut = new SevenZipCompressor(); zipOut.ArchiveFormat = OutArchiveFormat.Zip; zipOut.CompressionLevel = SevenZip.CompressionLevel.None; List<string> FileList = new List<string>(Search.FindFiles( basePath, includes, excludes, SearchOption.AllDirectories )); SevenZipBase.SetLibraryPath(Inits.EnsureBinaries()); zipOut.CompressFileDictionary( FileList.ToDictionary(f => f.Replace(basePath, null), f => f), inStream ); inStream.Position = 0; using (var outStream = new MemoryStream()) { using (var LzmaStream = new LzmaEncodeStream(outStream)) { int byt = 0; while ((byt = inStream.ReadByte()) != -1) LzmaStream.WriteByte((byte)byt); } return outStream.ToArray(); } } }
public bool Zipp(IEnumerable<string> iText, string iFileName, string iPassword) { CheckArguments(iText, iFileName); SevenZipCompressor sevenZipCompressor = new SevenZipCompressor() { DirectoryStructure = true, EncryptHeaders = true, DefaultItemName = "Default.txt" }; try { using (var instream = new MemoryStream()) { using (var streamwriter = new StreamWriter(instream) { AutoFlush = true }) { iText.Apply(t => streamwriter.WriteLine(t)); instream.Position = 0; using (Stream outstream = File.Create(iFileName)) { sevenZipCompressor.CompressStream(instream, outstream, iPassword); } } } } catch (Exception e) { Trace.WriteLine(string.Format("Problem zipping a text: {0}", e)); return false; } return true; }
public void CompressionTestsVerySimple(){ var tmp = new SevenZipCompressor(); //tmp.ScanOnlyWritable = true; //tmp.CompressFiles(@"d:\Temp\arch.7z", @"d:\Temp\log.txt"); //tmp.CompressDirectory(@"c:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\1033", @"D:\Temp\arch.7z"); tmp.CompressDirectory(testFold1, Path.Combine(tempFolder, TestContext.TestName + ".7z")); }
public void Compress(string sourceFilename, string targetFilename, FileMode fileMode, OutArchiveFormat archiveFormat, CompressionMethod compressionMethod, CompressionLevel compressionLevel, ZipEncryptionMethod zipEncryptionMethod, string password, int bufferSize, int preallocationPercent, bool check, Dictionary<string, string> customParameters) { bufferSize *= this._sectorSize; SevenZipCompressor compressor = new SevenZipCompressor(); compressor.FastCompression = true; compressor.ArchiveFormat = archiveFormat; compressor.CompressionMethod = compressionMethod; compressor.CompressionLevel = compressionLevel; compressor.DefaultItemName = Path.GetFileName(sourceFilename); compressor.DirectoryStructure = false; compressor.ZipEncryptionMethod = zipEncryptionMethod; foreach (var pair in customParameters) { compressor.CustomParameters[pair.Key] = pair.Value; } using (FileStream sourceFileStream = new FileStream(sourceFilename, FileMode.Open, FileAccess.Read, FileShare.None, bufferSize, Win32.FileFlagNoBuffering | FileOptions.SequentialScan)) { using (FileStream targetFileStream = new FileStream(targetFilename, fileMode, FileAccess.ReadWrite, FileShare.ReadWrite, 8, FileOptions.WriteThrough | Win32.FileFlagNoBuffering)) { this.Compress(compressor, sourceFileStream, targetFileStream, password, preallocationPercent, check, bufferSize); } } }
private void b_Compress_Click(object sender, EventArgs e) { SevenZipCompressor.SetLibraryPath(@"C:\Program Files\7-Zip\7z.dll"); SevenZipCompressor cmp = new SevenZipCompressor(); cmp.Compressing += new EventHandler<ProgressEventArgs>(cmp_Compressing); cmp.FileCompressionStarted += new EventHandler<FileNameEventArgs>(cmp_FileCompressionStarted); cmp.CompressionFinished += new EventHandler<EventArgs>(cmp_CompressionFinished); cmp.ArchiveFormat = (OutArchiveFormat)Enum.Parse(typeof(OutArchiveFormat), cb_Format.Text); cmp.CompressionLevel = (CompressionLevel)trb_Level.Value; cmp.CompressionMethod = (CompressionMethod)cb_Method.SelectedIndex; cmp.VolumeSize = chb_Volumes.Checked ? (int)nup_VolumeSize.Value : 0; string directory = tb_CompressDirectory.Text; string archFileName = tb_CompressOutput.Text; bool sfxMode = chb_Sfx.Checked; if (!sfxMode) { cmp.BeginCompressDirectory(directory, archFileName); } else { // Build SevenZipSharp with SFX /*SevenZipSfx sfx = new SevenZipSfx(); using (MemoryStream ms = new MemoryStream()) { cmp.CompressDirectory(directory, ms); sfx.MakeSfx(ms, archFileName.Substring(0, archFileName.LastIndexOf('.')) + ".exe"); }*/ } }
private SevenZip.SevenZipCompressor CreateCompressor() { var compressor = new SevenZip.SevenZipCompressor(); switch (ArchiveFormat) { case OutArchiveFormat.SevenZip: compressor.CompressionMethod = CompressionMethod.Lzma2; break; case OutArchiveFormat.Zip: compressor.CompressionMethod = CompressionMethod.Lzma; break; //case OutArchiveFormat.GZip: // break; //case OutArchiveFormat.BZip2: // break; //case OutArchiveFormat.Tar: // break; //case OutArchiveFormat.XZ: // break; default: // どうせ使わんし対応が面倒なので throw new NotImplementedException($"{ArchiveFormat}方式の圧縮は未対応です。"); } compressor.ArchiveFormat = ArchiveFormat; compressor.PreserveDirectoryRoot = false; compressor.CompressionLevel = CompressionLevel.Ultra; return(compressor); }
public static void CompressDirectory(string compressDirectory, string archFileName, OutArchiveFormat archiveFormat, CompressionLevel compressionLevel) { SevenZipCompressor.SetLibraryPath(LibraryPath); SevenZipCompressor cmp = new SevenZipCompressor(); cmp.ArchiveFormat = archiveFormat; cmp.CompressionLevel = compressionLevel; cmp.BeginCompressDirectory(compressDirectory, archFileName); }
/// <summary> /// Compresses files using gzip format /// </summary> /// <param name="files">The files.</param> /// <param name="destination">The destination.</param> public static void GZipFiles(string[] files, string destination) { SetupZlib(); SevenZipCompressor compressor = new SevenZipCompressor(); compressor.ArchiveFormat = OutArchiveFormat.GZip; compressor.CompressFiles(destination, files); }
public static void ZipFolder(string archivePath, string targetDir) { var compressor = new SevenZipCompressor(); compressor.ArchiveFormat = OutArchiveFormat.SevenZip; compressor.CompressionMode = CompressionMode.Create; compressor.TempFolderPath = System.IO.Path.GetTempPath(); compressor.CompressDirectory(targetDir, archivePath); }
public static void ZipFiles(string archivePath, params string[] targetFilesPath) { var compressor = new SevenZipCompressor(); compressor.ArchiveFormat = OutArchiveFormat.SevenZip; compressor.CompressionMode = CompressionMode.Create; compressor.TempFolderPath = System.IO.Path.GetTempPath(); //compressor.CompressDirectory(source, output); compressor.CompressFiles(archivePath, targetFilesPath); }
public void Pack(string outputPath) { SevenZipCompressor tmp = new SevenZipCompressor(); tmp.FileCompressionStarted += new EventHandler<FileInfoEventArgs>((s, e) => { Console.WriteLine(String.Format("[{0}%] {1}", e.PercentDone, e.FileInfo.Name)); }); tmp.CompressDirectory(_targetPath, outputPath, OutArchiveFormat.SevenZip); }
public void SerializationDemo(){ ArgumentException ex = new ArgumentException("blahblah"); System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); using (MemoryStream ms = new MemoryStream()) { bf.Serialize(ms, ex); SevenZipCompressor cmpr = new SevenZipCompressor(); cmpr.CompressStream(ms, File.Create(createTempFileName())); } }
public void packToZip(String filePathArchive, String romFolder) { if(!Directory.Exists(tempPath)){ Directory.CreateDirectory(tempPath); } archivePacker = new SevenZipCompressor(tempFolder); archivePacker.ArchiveFormat = OutArchiveFormat.Zip; archivePacker.BeginCompressDirectory(romFolder, filePathArchive, ""); }
private void Compress(string directory, string archFileName) { SevenZipCompressor.SetLibraryPath(AppDomain.CurrentDomain.BaseDirectory + "7z.dll"); SevenZipCompressor cmp = new SevenZipCompressor(); cmp.Compressing += new EventHandler<ProgressEventArgs>(cmp_Compressing); cmp.FileCompressionStarted += new EventHandler<FileNameEventArgs>(cmp_FileCompressionStarted); cmp.CompressionFinished += new EventHandler<EventArgs>(cmp_CompressionFinished); cmp.ArchiveFormat = OutArchiveFormat.SevenZip; cmp.CompressionLevel = CompressionLevel.Normal; cmp.BeginCompressDirectory(directory, archFileName); }
static public void compress(string source, string outputFileName) { if (source != null && outputFileName != null) { SevenZipCompressor.SetLibraryPath("7z.dll"); SevenZipCompressor cmp = new SevenZipCompressor(); cmp.Compressing += new EventHandler<ProgressEventArgs>(cmp_Compressing); cmp.FileCompressionStarted += new EventHandler<FileNameEventArgs>(cmp_FileCompressionStarted); cmp.CompressionFinished += new EventHandler<EventArgs>(cmp_CompressionFinished); cmp.ArchiveFormat = (OutArchiveFormat)Enum.Parse(typeof(OutArchiveFormat), "SevenZip"); cmp.CompressFiles(outputFileName, source); } }
private static void Compress(string savePath, string backupPath, CompressionLevel compressionLevel = CompressionLevel.None) { SevenZipCompressor compressor = new SevenZipCompressor(); compressor.CustomParameters.Add("mt", "on"); compressor.CompressionLevel = compressionLevel; compressor.ScanOnlyWritable = true; if (!Directory.Exists(backupPath)) Directory.CreateDirectory(backupPath); compressor.CompressDirectory(savePath, (Path.Combine(backupPath, GetTimeStamp()) + ".7z")); }
private void b_Compress_Click(object sender, RoutedEventArgs e) { SevenZipCompressor.SetLibraryPath(@"C:\Program Files\7-Zip\7z.dll"); SevenZipCompressor cmp = new SevenZipCompressor(); cmp.Compressing += new EventHandler<ProgressEventArgs>(cmp_Compressing); cmp.FileCompressionStarted += new EventHandler<FileNameEventArgs>(cmp_FileCompressionStarted); cmp.CompressionFinished += new EventHandler<EventArgs>(cmp_CompressionFinished); cmp.ArchiveFormat = (OutArchiveFormat)Enum.Parse(typeof(OutArchiveFormat), cb_Format.Text); cmp.CompressionLevel = (CompressionLevel)slider_Level.Value; string directory = tb_CompressFolder.Text; string archFileName = tb_CompressArchive.Text; cmp.BeginCompressDirectory(directory, archFileName); }
public static void SevenZIP(List<string> files, string output) { SevenZipExtractor.SetLibraryPath(ConfigurationManager.AppSettings["7ZIPDLL"]); SevenZipCompressor.SetLibraryPath(ConfigurationManager.AppSettings["7ZIPDLL"]); SevenZipCompressor compressor = new SevenZipCompressor(); compressor.ArchiveFormat = OutArchiveFormat.SevenZip; compressor.CompressionMode = CompressionMode.Create; compressor.TempFolderPath = System.IO.Path.GetTempPath(); //compressor.VolumeSize = 51200000;//50 MB compressor.CompressFiles(output, files.ToArray()); }
protected override void ExecuteCore() { SevenZipCompressor compressor = null; try { var files = this.GetAllSources().ToList(); foreach (var file in files) FileHelper.WaitForReady(FileHelper.GetDataFilePath(file)); long nextLength = 0, nextFile = 0; FileLength = files.Sum(file => new FileInfo(FileHelper.GetFilePath(file)).Length); compressor = new SevenZipCompressor { CompressionLevel = (CompressionLevel)Enum.Parse(typeof(CompressionLevel), TaskXml.GetAttributeValue("compressionLevel"), true) }; switch (Path.GetExtension(RelativePath).ToLowerInvariant()) { case ".7z": compressor.ArchiveFormat = OutArchiveFormat.SevenZip; break; case ".zip": compressor.ArchiveFormat = OutArchiveFormat.Zip; break; case ".tar": compressor.ArchiveFormat = OutArchiveFormat.Tar; break; } var filesStart = Path.GetFullPath(FileHelper.GetFilePath(string.Empty)).Length + 1; compressor.FileCompressionStarted += (sender, e) => { ProcessedSourceCount += nextFile; ProcessedFileLength += nextLength; nextFile = 1; nextLength = new FileInfo(e.FileName).Length; CurrentSource = e.FileName.Substring(filesStart); Save(); }; compressor.CompressFiles(FileHelper.GetFilePath(RelativePath), Path.GetFullPath(FileHelper.GetFilePath(BaseFolder)).Length + 1, files.Select(file => Path.GetFullPath(FileHelper.GetFilePath(file))).ToArray()); ProcessedSourceCount += nextFile; ProcessedFileLength += nextLength; Finish(); } catch (SevenZipException) { if (compressor == null) throw; throw new AggregateException(compressor.Exceptions); } }
public string CreatePackage() { // Create the package file if (File.Exists(InstallPerpParms.FileLocation.ToString() + "\\profile.cfg") == true) { File.Delete(InstallPerpParms.FileLocation.ToString() + "\\profile.cfg"); } File.Create(InstallPerpParms.FileLocation.ToString() + "\\profile.cfg").Close(); using( StreamWriter ProfileStream = new StreamWriter(InstallPerpParms.FileLocation.ToString() + "\\profile.cfg")) { ProfileStream.WriteLine("GameName=" + PackageFile.GameName); ProfileStream.WriteLine("GameDir=" + PackageFile.GameDir.ToString()); ProfileStream.WriteLine("CurrentVersion=" + PackageFile.VersionNumber); ProfileStream.WriteLine("UpdateURL=" + PackageFile.UpdateURL.ToString()); ProfileStream.WriteLine("DescriptionURL=" + PackageFile.DescURL.ToString()); ProfileStream.WriteLine("GameType=" + PackageFile.TypeGame.ToString()); ProfileStream.WriteLine("LoginType=" + PackageFile.TypeLogin.ToString()); ProfileStream.WriteLine("CommandLineArgs=" + PackageFile.CommandLine); ProfileStream.Flush(); ProfileStream.Close(); } // create installer SevenZipSfx Installer = new SevenZipSfx(); SevenZipCompressor Compress = new SevenZipCompressor("C:\\Temp\\Compress"); // installer settings Dictionary<string, string> Settings = new Dictionary<string, string> { { "Title", PackageFile.GameName + " " + PackageFile.VersionNumber }, { "InstallPath", PackageFile.GameDir }, { "BeginPrompt", "Yükleme işlemi başlatılsın mı?" }, { "CancelPrompt", "Yükleme işlemi iptal edilecek?" }, { "OverwriteMode", "2" }, { "GUIMode", "1" }, { "ExtractDialogText", "Dosyalar ayıklanıyor" }, { "ExtractTitle", "Ayıklama İşlemi" }, { "ErrorTitle", "Hata!" } }; Compress.CompressDirectory(InstallPerpParms.FileLocation.ToString(), "c:\\temp\\compress.7zip"); Installer.ModuleFileName = Directory.GetCurrentDirectory() + "\\7zxSD_LZMA.sfx"; Installer.MakeSfx("c:\\temp\\compress.7zip", Settings, Directory.GetCurrentDirectory() + "\\" + InstallPerpParms.FileName); return "Done"; }
public int Compress(PointCloudTile tile, byte[] uncompressedBuffer, int count, byte[] compressedBuffer) { SevenZipCompressor compressor = new SevenZipCompressor { CompressionMethod = SevenZip.CompressionMethod.Lzma2, CompressionLevel = CompressionLevel.Fast }; MemoryStream uncompressedStream = new MemoryStream(uncompressedBuffer, 0, count, false); // custom stream is required because the position is always 32 instead of the end of the stream MemorableMemoryStream compressedStream = new MemorableMemoryStream(compressedBuffer); compressor.CompressStream(uncompressedStream, compressedStream); return (int)compressedStream.MaxPosition; }
/// <summary> /// Compresses a directory into a single archive /// </summary> /// <param name="inDir">The path to the directory to compress</param> /// <param name="outFile">The archive name to create</param> /// <param name="notify">Flag to notify user when finished</param> public static void CompressDirectory(string inDir, string outFile, bool notify = false) { SevenZipBase.SetLibraryPath(PathHelper.SevenZipLibrary); if (_compressor == null) { _compressor = new SevenZipCompressor { ArchiveFormat = OutArchiveFormat.SevenZip, CompressionLevel = CompressionLevel.Ultra, CompressionMode = CompressionMode.Create }; } _notify = notify; _compressor.TempFolderPath = Path.GetTempPath(); _compressor.CompressDirectory(inDir, outFile); File.SetCreationTime(outFile, DateTime.Now); }
public override void Open() { string source_folder = @"D:\test"; //путь к папке, которую нужно поместить в архив string archive_name = "qwerty.zip"; //имя архива string library_source = "SevenZipSharp.dll"; //Путь к файлу 7zip.dll if (File.Exists(library_source)) //Если библиотека 7zip существует { SevenZipBase.SetLibraryPath(library_source); //Подгружаем библиотеку 7zip var compressor = new SevenZipCompressor(); //Объявляем переменную архиватора compressor.ArchiveFormat = OutArchiveFormat.SevenZip; //Выбираем формат архива compressor.CompressionLevel = CompressionLevel.Ultra; // ультра режим сжатия compressor.CompressionMode = CompressionMode.Create; //подтверждаются настройки compressor.TempFolderPath = System.IO.Path.GetTempPath();//объявляется временная папка compressor.CompressDirectory(source_folder, archive_name, false); //сам процесс сжатия } }
/// <summary> /// Creates a cache file for the given mod, containing the specified files. /// </summary> /// <param name="p_modMod">The mod for which to create the cache file.</param> /// <param name="p_strFilesToCacheFolder">The folder containing the files to put into the cache.</param> /// <returns>The cache file for the specified mod, or <c>null</c> /// if there were no files to cache.</returns> public Archive CreateCacheFile(IMod p_modMod, string p_strFilesToCacheFolder) { if (!String.IsNullOrEmpty(p_strFilesToCacheFolder)) { string[] strFilesToCompress = Directory.GetFiles(p_strFilesToCacheFolder, "*.*", SearchOption.AllDirectories); if (strFilesToCompress.Length > 0) { string strCachePath = GetCacheFilePath(p_modMod); SevenZipCompressor szcCompressor = new SevenZipCompressor(); szcCompressor.ArchiveFormat = OutArchiveFormat.Zip; szcCompressor.CompressionLevel = CompressionLevel.Ultra; szcCompressor.CompressDirectory(p_strFilesToCacheFolder, strCachePath); return new Archive(strCachePath); } } return null; }
public void execute(MinecraftPaths p) { Regex zip = new Regex(@"ZIP$"); if (zip.IsMatch(target)) { SevenZip.SevenZipCompressor comp = new SevenZipCompressor(); Match m = zip.Match(target); target = target.Remove(m.Index) + "NAME"; comp.CompressDirectory(p.resolvePath(source, ExtraTags), p.resolvePath(target, ExtraTags)); } else { SMMMUtil.FileSystemUtils.CopyDirectory(p.resolvePath(source, ExtraTags), p.resolvePath(target, ExtraTags)); } }
/// <summary> /// 压缩字节数组 /// </summary> /// <param name="input">字节数组</param> /// <returns>压缩后的字节数组</returns> public static byte[] Compress(byte[] input) { byte[] compressed = null; SevenZipCompressor compressor = new SevenZipCompressor(); compressor.CompressionMethod = CompressionMethod.Ppmd; compressor.CompressionLevel = CompressionLevel.High; using (MemoryStream ms = new MemoryStream(input)) { using (MemoryStream outMs = new MemoryStream()) { compressor.CompressStream(ms, outMs); outMs.Position = 0; compressed = new byte[outMs.Length]; outMs.Read(compressed, 0, compressed.Length); } } return compressed; }
public void Build(Package package, string path) { var archiveName = package.Manifest.Name.ToLowerInvariant().Replace(" ", "-") + "-v" + package.Manifest.Version; var archive = Path.Combine(FilePaths.PackageRepository, archiveName) + FileTypes.Package; var file = new FileInfo(Assembly.GetExecutingAssembly().Location); SevenZipCompressor.SetLibraryPath(Path.Combine(file.DirectoryName, "7z.dll")); var sevenZipCompressor = new SevenZipCompressor { ArchiveFormat = OutArchiveFormat.SevenZip, CompressionLevel = CompressionLevel.Ultra }; sevenZipCompressor.Compressing += this.Compressing; sevenZipCompressor.CompressionFinished += this.CompressingFinished; sevenZipCompressor.CompressFiles(archive, package.Manifest.Files.Select(manifestFile => manifestFile.File).ToArray()); }
internal string FirstSaveDynamicBook(Book bk) { try { // create a temp folder string tempFolder = DirectoryHelper.Combine(CBRFolders.Temp, Path.GetFileNameWithoutExtension(bk.FilePath)); DirectoryHelper.Check(tempFolder); //extract the book content ExtractBook(bk, tempFolder); //serialize all frames even empty to create the files in the zip foreach (Page pg in bk.Pages) { XmlHelper.Serialize(Path.Combine(tempFolder, pg.FileName + ".dynamics.xml"), pg.Frames.ToList()); } // create a new file by compressing all temp folder content string newComic = bk.FilePath.Replace(Path.GetExtension(bk.FilePath), ".dcb"); SevenZip.SevenZipCompressor cp = new SevenZip.SevenZipCompressor(); cp.ArchiveFormat = SevenZip.OutArchiveFormat.Zip; string[] outputFiles = new DirectoryInfo(tempFolder).GetFiles("*.*").Select(p => p.FullName).ToArray(); using (FileStream fs = new FileStream(newComic, FileMode.Create)) { cp.CompressFiles(fs, outputFiles); } //delete the temp folder Directory.Delete(tempFolder, true); return(newComic); } catch (Exception err) { LogHelper.Manage("BookService:FirstSaveDynamicBook", err); } return(null); }
public static byte[] CompressBytes(byte[] data) { byte[] compressedData = null; SevenZipCompressor compressor = new SevenZipCompressor(); compressor.CompressionMethod = CompressionMethod.Ppmd; compressor.CompressionLevel = SevenZip.CompressionLevel.Ultra; compressor.ScanOnlyWritable = true; compressor.DefaultItemName = "T"; using (MemoryStream msin = new MemoryStream(data)) { using (MemoryStream msout = new MemoryStream()) { compressor.CompressStream(msin, msout); compressedData = msout.ToArray(); } } return compressedData; }
public static byte[] CompressBytes(byte[] data, CompressionLevel CompressionLevel, CompressionMethod CompressionMethod = CompressionMethod.Default ) { Inits.EnsureBinaries(); using (var inStream = new MemoryStream(data)) { using (var outStream = new MemoryStream()) { var compressor = new SevenZipCompressor(); compressor.CompressionLevel = (SevenZip.CompressionLevel)(int)CompressionLevel; compressor.CompressionMethod = (SevenZip.CompressionMethod)(int)CompressionMethod; compressor.ScanOnlyWritable = true; compressor.CompressStream(inStream, outStream); return outStream.ToArray(); } } }
public int compressArchive(Dictionary<string, Stream> files, string outFileName) { // create output archive SevenZipCompressor compressor = new SevenZipCompressor(); try { var dict = new Dictionary<string, Stream>(); foreach (var fileName in files.Keys) dict.Add(fileName, files[fileName]); compressor.CompressStreamDictionary(dict, outFileName); return 0; } catch (Exception ex) { Console.Error.WriteLine("Error: Could not create output archive: " + outFileName); Console.Error.WriteLine("\t" + ex.Message); return 1; } }
/// <summary> /// Initializes a new instance of the ArchiveUpdateCallback class /// </summary> /// <param name="streamDict">Dictionary<file stream, name of the archive entry></param> /// <param name="compressor">The owner of the callback</param> /// <param name="updateData">The compression parameters.</param> /// <param name="directoryStructure">Preserve directory structure.</param> public ArchiveUpdateCallback( IDictionary <string, Stream> streamDict, SevenZipCompressor compressor, UpdateData updateData, bool directoryStructure) { Init(streamDict, compressor, updateData, directoryStructure); }
/// <summary> /// Initializes a new instance of the ArchiveUpdateCallback class /// </summary> /// <param name="files">Array of files to pack</param> /// <param name="rootLength">Common file names root length</param> /// <param name="compressor">The owner of the callback</param> /// <param name="updateData">The compression parameters.</param> /// <param name="directoryStructure">Preserve directory structure.</param> public ArchiveUpdateCallback( FileInfo[] files, int rootLength, SevenZipCompressor compressor, UpdateData updateData, bool directoryStructure) { Init(files, rootLength, compressor, updateData, directoryStructure); }
private void Deployment_BackgroundThread(object sender, DoWorkEventArgs e) { var referencedFiles = ModBeingDeployed.GetAllRelativeReferences(); string archivePath = e.Argument as string; //Key is in-archive path, value is on disk path var archiveMapping = new Dictionary <string, string>(); SortedSet <string> directories = new SortedSet <string>(); foreach (var file in referencedFiles) { var path = Path.Combine(ModBeingDeployed.ModPath, file); var directory = Directory.GetParent(path).FullName; if (directory.Length <= ModBeingDeployed.ModPath.Length) { continue; //root file or directory. } directory = directory.Substring(ModBeingDeployed.ModPath.Length + 1); //nested folders with no folders var relativeFolders = directory.Split('\\'); string buildingFolderList = ""; foreach (var relativeFolder in relativeFolders) { if (buildingFolderList != "") { buildingFolderList += @"\\"; } buildingFolderList += relativeFolder; if (directories.Add(buildingFolderList)) { archiveMapping[buildingFolderList] = null; } } } archiveMapping.AddRange(referencedFiles.ToDictionary(x => x, x => Path.Combine(ModBeingDeployed.ModPath, x))); var compressor = new SevenZip.SevenZipCompressor(); //compressor.CompressionLevel = CompressionLevel.Ultra; compressor.CustomParameters.Add(@"s", @"on"); if (!MultithreadedCompression) { compressor.CustomParameters.Add(@"mt", @"off"); } compressor.CustomParameters.Add(@"yx", @"9"); //compressor.CustomParameters.Add("x", "9"); compressor.CustomParameters.Add(@"d", @"28"); string currentDeploymentStep = M3L.GetString(M3L.string_mod); compressor.Progressing += (a, b) => { //Debug.WriteLine(b.AmountCompleted + "/" + b.TotalAmount); ProgressMax = b.TotalAmount; ProgressValue = b.AmountCompleted; var now = DateTime.Now; if ((now - lastPercentUpdateTime).Milliseconds > ModInstaller.PERCENT_REFRESH_COOLDOWN) { //Don't update UI too often. Once per second is enough. string percent = (ProgressValue * 100.0 / ProgressMax).ToString(@"0.00"); OperationText = $@"[{currentDeploymentStep}] {M3L.GetString(M3L.string_deploymentInProgress)} {percent}%"; lastPercentUpdateTime = now; } //Debug.WriteLine(ProgressValue + "/" + ProgressMax); }; compressor.FileCompressionStarted += (a, b) => { Debug.WriteLine(b.FileName); }; compressor.CompressFileDictionary(archiveMapping, archivePath); compressor.CustomParameters.Clear(); //remove custom params as it seems to force LZMA compressor.CompressionMode = CompressionMode.Append; compressor.CompressionLevel = CompressionLevel.None; currentDeploymentStep = @"moddesc.ini"; compressor.CompressFiles(archivePath, new string[] { Path.Combine(ModBeingDeployed.ModPath, @"moddesc.ini") }); OperationText = M3L.GetString(M3L.string_deploymentSucceeded); Utilities.HighlightInExplorer(archivePath); }
/// <summary> /// Initializes a new instance of the ArchiveUpdateCallback class /// </summary> /// <param name="stream">The input stream</param> /// <param name="compressor">The owner of the callback</param> /// <param name="updateData">The compression parameters.</param> /// <param name="directoryStructure">Preserve directory structure.</param> public ArchiveUpdateCallback( Stream stream, SevenZipCompressor compressor, UpdateData updateData, bool directoryStructure) { Init(stream, compressor, updateData, directoryStructure); }
public static bool Export(string exportPath) { try { Set7ZipLibraryPath(); SevenZipCompressor zip = new SevenZipCompressor(); zip.ArchiveFormat = OutArchiveFormat.SevenZip; zip.CompressionLevel = CompressionLevel.Normal; zip.CompressionMethod = CompressionMethod.Lzma2; Dictionary<string, string> files = new Dictionary<string, string>(); if (Program.Settings.ExportSettings) { AddFileToDictionary(files, Program.ApplicationConfigFilePath); AddFileToDictionary(files, Program.HotkeysConfigFilePath); AddFileToDictionary(files, Program.UploadersConfigFilePath); AddFileToDictionary(files, Program.GreenshotImageEditorConfigFilePath); } if (Program.Settings.ExportHistory) { AddFileToDictionary(files, Program.HistoryFilePath); } if (Program.Settings.ExportLogs) { foreach (string file in Directory.GetFiles(Program.LogsFolder, "*.txt", SearchOption.TopDirectoryOnly)) { AddFileToDictionary(files, file, Path.GetFileName(Program.LogsFolder)); } } zip.CompressFileDictionary(files, exportPath); return true; } catch (Exception e) { DebugHelper.WriteException(e); MessageBox.Show("Error while exporting backup:\r\n\r\n" + e, "ShareX - Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } return false; }