public static MemoryStream DecompressToMemoryStream(byte[] compressedBytes, ECompressionType compressType, int decompressedSize = -1) { MemoryStream decompressedStream; switch (compressType) { case ECompressionType.LzMa: //LZMA { decompressedStream = new MemoryStream(); SevenZipHelper.DecompressData(compressedBytes, decompressedStream, decompressedSize); break; } case ECompressionType.Lz4: //LZ4 case ECompressionType.Lz4Hc: //LZ4HC { var decompressedBytes = new byte[decompressedSize]; LZ4Codec.Decode(compressedBytes, 0, compressedBytes.Length, decompressedBytes, 0, decompressedSize); decompressedStream = new MemoryStream(decompressedBytes); break; } //case CompressionType.LzHam: //LZHAM case ECompressionType.None: //None default: { decompressedStream = new MemoryStream(compressedBytes); break; } } return(decompressedStream); }
public static byte[] Compress(byte[] data, ECompressionType compressType) //, int start = 0, int count = 0) { byte[] compressedData; switch (compressType) { case ECompressionType.LzMa: compressedData = SevenZipHelper.CompressData(data); break; case ECompressionType.Lz4: //LZ4 case ECompressionType.Lz4Hc: //LZ4HC compressedData = new byte[LZ4Codec.MaximumOutputSize(data.Length)]; var compressedSize = LZ4Codec.Encode(data, 0, data.Length, compressedData, 0, compressedData.Length); Array.Resize(ref compressedData, compressedSize); break; //case CompressionType.LzHam: //LZHAM case ECompressionType.None: //None default: { compressedData = data; break; } } return(compressedData); }
public void ZipOutputStreamEncryptEmptyEntries( [Values] UseZip64 useZip64, [Values(0, 128, 256)] int keySize, [Values(CompressionMethod.Stored, CompressionMethod.Deflated)] CompressionMethod compressionMethod) { using (var ms = new MemoryStream()) { using (var zipOutputStream = new ZipOutputStream(ms)) { zipOutputStream.IsStreamOwner = false; zipOutputStream.Password = "******"; zipOutputStream.UseZip64 = useZip64; ZipEntry zipEntry = new ZipEntry("emptyEntry") { AESKeySize = keySize, CompressionMethod = compressionMethod, CompressedSize = 0, Crc = 0, Size = 0, }; zipOutputStream.PutNextEntry(zipEntry); zipOutputStream.CloseEntry(); } SevenZipHelper.VerifyZipWith7Zip(ms, "password"); } }
public MemoryStream DecompressEntry(int Index) { MemoryStream result = new MemoryStream(); FileEntryStruct e = Files[Index]; uint count = 0; byte[] inputBlock; byte[] outputBlock = new byte[Header.MaxBlockSize]; long left = e.RealUncompressedSize; FileStream fs = new FileStream(MyFileName, FileMode.Open, FileAccess.Read); fs.Seek(e.BlockOffsets[0], SeekOrigin.Begin); byte[] buff; if (e.BlockSizeIndex == 0xFFFFFFFF) { buff = new byte[e.RealUncompressedSize]; fs.Read(buff, 0, buff.Length); result.Write(buff, 0, buff.Length); } else { while (left > 0) { uint compressedBlockSize = (uint)e.BlockSizes[count]; if (compressedBlockSize == 0) { compressedBlockSize = Header.MaxBlockSize; } if (compressedBlockSize == Header.MaxBlockSize || compressedBlockSize == left) { buff = new byte[compressedBlockSize]; fs.Read(buff, 0, buff.Length); result.Write(buff, 0, buff.Length); left -= compressedBlockSize; } else { var uncompressedBlockSize = (uint)Math.Min(left, Header.MaxBlockSize); if (compressedBlockSize < 5) { throw new Exception("compressed block size smaller than 5"); } inputBlock = new byte[compressedBlockSize]; fs.Read(inputBlock, 0, (int)compressedBlockSize); uint actualUncompressedBlockSize = uncompressedBlockSize; uint actualCompressedBlockSize = compressedBlockSize; outputBlock = SevenZipHelper.Decompress(inputBlock, (int)actualUncompressedBlockSize); if (outputBlock.Length != actualUncompressedBlockSize) { throw new Exception("Decompression Error"); } result.Write(outputBlock, 0, (int)actualUncompressedBlockSize); left -= uncompressedBlockSize; } count++; } } fs.Close(); return(result); }
/// <summary> /// Extracts a zipped template, and merges better info from another vstemplate file, then rezips the file /// C:\Users\dkhen\Documents\Visual Studio 2010\My Exported Templates /// </summary> /// <param name="zipFile"></param> void FixTemplate(string zipFile, bool isItemTemplate) { var vsTemplateFilename = "MyTemplate.vstemplate"; var dir = SevenZipHelper.ExtractToDir(zipFile); vsTemplateFilename = Path.Combine(dir, vsTemplateFilename); var doc1 = XDocument.Load(vsTemplateFilename); var doc2 = XDocument.Load(@"C:\Projects\SharpKit\trunk\src\SharpKit.Release\VSTemplates10\" + Path.GetFileNameWithoutExtension(zipFile) + ".vstemplate"); XNamespace xn = "http://schemas.microsoft.com/developer/vstemplate/2005"; var el1 = doc1.Root.Element(xn + "TemplateData"); var el2 = doc2.Root.Element(xn + "TemplateData"); foreach (var ch2 in el2.Elements()) { var ch1 = el1.Element(ch2.Name); ch1.Value = ch2.Value; } doc1.Save(vsTemplateFilename); FileHelper.DeleteFileIfExists(zipFile + ".bak"); File.Move(zipFile, zipFile + ".bak"); SevenZipHelper.ZipDirectory(dir, zipFile); Directory.Delete(dir, true); var newZipFile = el1.Element(xn + "Name").Value + ".zip"; var zipDir = @"C:\Projects\SharpKit\trunk\src\SharpKit.Release\VSTemplates10\ProjectTemplates\"; if (isItemTemplate) { zipDir = zipDir.Replace("ProjectTemplates", "ItemTemplates"); } newZipFile = Path.Combine(zipDir, newZipFile); File.Copy(zipFile, newZipFile, true); }
public void EditorTest() { //Arrange var gameObject = new GameObject(); short rating = 1234; string ratingString = rating.ToString(); byte[] stringBytes = Encoding.UTF8.GetBytes(ratingString); byte[] shortBytes = BitConverter.GetBytes(rating); byte[] compressedShort = SevenZipHelper.Compress(shortBytes); byte[] compressedString = SevenZipHelper.Compress(stringBytes); Debug.Log(stringBytes.Length); Debug.Log(shortBytes.Length); Debug.Log("compressed short " + compressedShort.Length); Debug.Log("compressed string " + compressedString.Length); Debug.Log(ratingString); //Act //Try to rename the GameObject var newGameObjectName = "My game object"; gameObject.name = newGameObjectName; //Assert //The object has a new name Assert.AreEqual(newGameObjectName, gameObject.name); }
public static void SaveFile(string filePath, ReplayFile replay) { using (ReplayWriter beatmapWriter = new ReplayWriter(File.Open(filePath, FileMode.Create))) { beatmapWriter.Write(replay.Mode); beatmapWriter.Write(replay.Version); beatmapWriter.Write(replay.BeatmapHash); beatmapWriter.Write(replay.PlayerName); beatmapWriter.Write(replay.ReplayHash); beatmapWriter.Write(replay.Count300); beatmapWriter.Write(replay.Count100); beatmapWriter.Write(replay.Count50); beatmapWriter.Write(replay.CountGeki); beatmapWriter.Write(replay.CountKatu); beatmapWriter.Write(replay.CountMiss); beatmapWriter.Write(replay.Score); beatmapWriter.Write(replay.MaxCombo); beatmapWriter.Write(replay.FullCombo); beatmapWriter.Write(replay.UsedMods); beatmapWriter.Write(replay.PerformanceGraphData); beatmapWriter.Write(replay.ReplayDate); string[] list = Encoding.ASCII.GetString(SevenZipHelper.Decompress(replay.Replay)).Split(','); beatmapWriter.Write(replay.Replay); beatmapWriter.Write(replay.Long0); } }
/// <summary> /// 立即安装 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void materialTextButton1_Click(object sender, EventArgs e) { if (this.extractProgress.Value > 0 && this.extractProgress.Value < 100) { MessageBox.Show("正在安装中。。。"); return; } this.extractProgress.Visible = true;// 显示进度条 string sPath = Path.Combine(Environment.CurrentDirectory, InstallerConfig.Config.Install7ZFile); string tPath = m_curInstallExePath; if (!Directory.Exists(tPath)) { Directory.CreateDirectory(tPath); } if (Directory.GetFiles(tPath).Length > 0) // 如果目标目录存文件, 先删除 { try { FileOperationHelper.RemoveFullFolder(tPath); }catch (Exception ex) { MessageBox.Show(ex.Message); } } var thread = new Thread(() => SevenZipHelper.Extract(sPath, tPath)) { Name = "InstallThread", IsBackground = true }; thread.Start(); }
/// <summary> /// 快速安装 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void materialTextButton3_Click(object sender, EventArgs e) { if (this.extractProgress.Value > 0 && this.extractProgress.Value < 100) { MessageBox.Show("正在安装中。。。"); return; } this.customInstallPanel.Visible = false; // 隐藏界面 this.extractProgress.Visible = true; // 显示进度条 string sPath = Path.Combine(Environment.CurrentDirectory, InstallerConfig.Config.Install7ZFile); string tPath = m_curInstallExePath; if (!Directory.Exists(tPath)) { Directory.CreateDirectory(tPath); } var thread = new Thread(() => SevenZipHelper.Extract(sPath, tPath)) { Name = "InstallThread", IsBackground = true }; thread.Start(); }
private void ReadPre530Metadata(EndianReader reader) { switch (Header.Type) { case BundleType.UnityRaw: { Metadata = new BundleMetadata(m_filePath); Metadata.ReadPre530(reader); } break; case BundleType.UnityWeb: case BundleType.HexFA: { // read only last chunk. wtf? ChunkInfo chunkInfo = Header.ChunkInfos[Header.ChunkInfos.Count - 1]; using (SmartStream stream = SmartStream.CreateMemory(new byte[chunkInfo.DecompressedSize])) { SevenZipHelper.DecompressLZMASizeStream(reader.BaseStream, chunkInfo.CompressedSize, stream); Metadata = new BundleMetadata(m_filePath); using (EndianReader decompressReader = new EndianReader(stream, EndianType.BigEndian)) { Metadata.ReadPre530(decompressReader); } } } break; default: throw new NotSupportedException($"Bundle type {Header.Type} isn't supported before 530 generation"); } }
private void ReadBlocks(EndianBinaryReader varReader, Stream varBlocksStream) { foreach (var blockInfo in BlocksInfo) { switch (blockInfo.GetCompressionType()) { default: //None { varReader.BaseStream.CopyTo(varBlocksStream, blockInfo.compressedSize); break; } case Compression.CompressionType.kCompressionLzma: //LZMA { SevenZipHelper.StreamDecompress(varReader.BaseStream, varBlocksStream, blockInfo.compressedSize, blockInfo.uncompressedSize); break; } case Compression.CompressionType.kCompressionLz4: //LZ4 case Compression.CompressionType.kCompressionLz4HC: //LZ4HC { var compressedStream = new MemoryStream(varReader.ReadBytes((int)blockInfo.compressedSize)); using (var lz4Stream = new Lz4DecoderStream(compressedStream)) { lz4Stream.CopyTo(varBlocksStream, blockInfo.uncompressedSize); } break; } } } varBlocksStream.Position = 0; }
private SmartStream ReadPre530Metadata(BundleFileReader reader) { switch (Header.Type) { case BundleType.UnityRaw: { Metadata.Read(reader); return(m_stream.CreateReference()); } case BundleType.UnityWeb: { // read only last chunk. wtf? ChunkInfo chunkInfo = Header.ChunkInfos[Header.ChunkInfos.Count - 1]; using (SmartStream stream = SmartStream.CreateMemory(new byte[chunkInfo.DecompressedSize])) { SevenZipHelper.DecompressLZMASizeStream(reader.BaseStream, chunkInfo.CompressedSize, stream); using (BundleFileReader decompressReader = new BundleFileReader(stream, reader.EndianType, reader.Generation)) { Metadata.Read(decompressReader); } return(stream.CreateReference()); } } default: throw new NotSupportedException($"Bundle type {Header.Type} isn't supported before 530 generation"); } }
private void ReadReplay(bool replayDecompress) { CompressedReplayData = ReadByteArray(); if (replayDecompress) { ReplayFrames = new List <ReplayFrame>(); DecompressedReplayData = SevenZipHelper.Decompress(CompressedReplayData); string replayData = Encoding.ASCII.GetString(DecompressedReplayData); if (replayData.Length > 0) { string[] replayLines = replayData.Split(','); ReplayFrame lastFrame; if (ReplayFrames.Count > 0) { lastFrame = ReplayFrames[ReplayFrames.Count - 1]; } else { lastFrame = new ReplayFrame(0, 0, 0); } foreach (string replayLine in replayLines) { if (replayLine.Length == 0) { continue; } string[] data = replayLine.Split('|'); if (data.Length < 4) { continue; } if (data[0] == "-12345") { Seed = int.Parse(data[3]); continue; } ReplayFrame nextFrame = new ReplayFrame( int.Parse(data[0]) + lastFrame.Time, float.Parse(data[1], _nfi), float.Parse(data[2], _nfi) ); ReplayFrames.Add(nextFrame); lastFrame = nextFrame; } } } if (Version >= 20140721) { OnlineId = _reader.ReadInt64(); } }
public static void ExportReplay(Score score) { if (!Directory.Exists("Replays")) { Directory.CreateDirectory("Replays"); } if (score.rawReplayCompressed == null) { score.rawReplayCompressed = SevenZipHelper.Compress(new ASCIIEncoding().GetBytes(score.replayFormatted)); } string filename = string.Format("{0} - {1} ({2:yyyyMMddhhmmss}).osr", score.playerName, BeatmapManager.Current.DisplayTitle, score.date.ToUniversalTime()); filename = "Replays\\" + GeneralHelper.WindowsFilenameStrip(filename); Stream stream = File.Open(filename, FileMode.Create); BinaryFormatter bformatter = new BinaryFormatter(); bformatter.Serialize(stream, score); stream.Close(); GameBase.ShowMessage("Saved replay to " + filename, Color.BlueViolet, 6000); }
public bool Read(AssetsFileReader reader) { header = new ClassDatabaseFileHeader(); header.Read(reader); if (header.header != "cldb" || header.fileVersion > 4 || header.fileVersion < 1) { valid = false; return(valid); } classes = new List <ClassDatabaseType>(); long classTablePos = reader.Position; AssetsFileReader newReader = reader; if (header.compressionType != 0) { classTablePos = 0; MemoryStream ms; if (header.compressionType == 1) //lz4 { byte[] uncompressedBytes = new byte[header.uncompressedSize]; using (MemoryStream tempMs = new MemoryStream(reader.ReadBytes((int)header.compressedSize))) { Lz4DecoderStream decoder = new Lz4DecoderStream(tempMs); decoder.Read(uncompressedBytes, 0, (int)header.uncompressedSize); decoder.Dispose(); } ms = new MemoryStream(uncompressedBytes); } else if (header.compressionType == 2) //lzma { using (MemoryStream tempMs = new MemoryStream(reader.ReadBytes((int)header.compressedSize))) { ms = SevenZipHelper.StreamDecompress(tempMs); } } else { valid = false; return(valid); } newReader = new AssetsFileReader(ms); newReader.bigEndian = false; } newReader.Position = header.stringTablePos; stringTable = newReader.ReadBytes((int)header.stringTableLen); newReader.Position = classTablePos; uint size = newReader.ReadUInt32(); for (int i = 0; i < size; i++) { ClassDatabaseType cdt = new ClassDatabaseType(); cdt.Read(newReader, header.fileVersion, header.flags); classes.Add(cdt); } valid = true; return(valid); }
public void ExtractTest() { string sPath = "C:/Users/zhanghui03/source/repos/DirectorEditor/TestResources/testzip.7z"; string tPath = "C:/Users/zhanghui03/source/repos/DirectorEditor/TestResources/xixi"; SevenZipHelper.Extract(sPath, tPath); }
internal void ReadReplayData() { if (rawReplayCompressed == null) { return; } if (replay == null) { replay = new List <bReplayFrame>(); } else { replay.Clear(); } try { ReadReplayData(new ASCIIEncoding().GetString(SevenZipHelper.Decompress(rawReplayCompressed))); } catch (Exception) { replay.Clear(); } #if DEBUG StreamWriter w = File.CreateText("replay.txt"); foreach (bReplayFrame f in replay) { w.WriteLine("{0} {1} {2} {3} {4} {5} {6}", f.time, f.mouseX, f.mouseY, f.mouseLeft1, f.mouseLeft2, f.mouseRight1, f.mouseRight2); } w.Close(); #endif }
private static void WriteToFileQueue(object source, ElapsedEventArgs e, bool shuttingDown = false) { if (!shuttingDown) { ChangeFileName(); } ChangeFileNameWaitHandle.WaitOne(); // wait when the file name is being changed var bufferedData = new RoomInfoWrapper[JsonDataQueue.Count]; lock (JsonDataQueue) { JsonDataQueue.CopyTo(bufferedData, 0); JsonDataQueue.Clear(); } var utf8Text = JsonConvert.SerializeObject(bufferedData); var byteText = Encoding.ASCII.GetBytes(utf8Text); var b = SevenZipHelper.Compress(byteText); _sw.Write(Encoding.UTF8.GetString(b)); /*Console.WriteLine( * Encoding.ASCII.GetString( * SevenZipHelper.Decompress( * b)).Substring(0,400));*/ }
private void CompressDoUpdateHelper(byte[] content, string name, TypeName typeName, bool compress) { if (compress) { content = SevenZipHelper.Compress(content); } DoUpdateResource(typeName.ToString() + (compress ? "_LZMA" : ""), name, content); }
public void CreateZipWithEncryptedEntries(string password, int keySize, CompressionMethod compressionMethod = CompressionMethod.Deflated) { using (var ms = new MemoryStream()) { WriteEncryptedZipToStream(ms, password, keySize, compressionMethod); SevenZipHelper.VerifyZipWith7Zip(ms, password); } }
public void BytesCompressionTest() { byte[] messageBytes = message.ToBytes(); Debug.Log("uncompressed length: " + messageBytes.Length); byte[] compressedMessageBytes = SevenZipHelper.Compress(messageBytes); Debug.Log("compressed length: " + compressedMessageBytes.Length); Expect(compressedMessageBytes.Length, LessThan(messageBytes.Length)); }
public TextAsset(AssetPreloadData preloadData, bool readSwitch) { AssetsFile sourceFile = preloadData.sourceFile; EndianStream stream = preloadData.sourceFile.a_Stream; stream.Position = preloadData.Offset; preloadData.extension = ".txt"; if (sourceFile.platform == -2) { uint num2 = stream.ReadUInt32(); PPtr ptr = sourceFile.ReadPPtr(); PPtr ptr2 = sourceFile.ReadPPtr(); } this.m_Name = stream.ReadAlignedString(stream.ReadInt32()); if (this.m_Name != "") { preloadData.Name = this.m_Name; } else { preloadData.Name = preloadData.TypeString + " #" + preloadData.uniqueID; } int count = stream.ReadInt32(); if (readSwitch) { this.m_Script = new byte[count]; stream.Read(this.m_Script, 0, count); if (this.m_Script[0] == 0x5d) { this.m_Script = SevenZipHelper.Decompress(this.m_Script); } if ((this.m_Script[0] == 60) || ((((this.m_Script[0] == 0xef) && (this.m_Script[1] == 0xbb)) && (this.m_Script[2] == 0xbf)) && (this.m_Script[3] == 60))) { preloadData.extension = ".xml"; } } else { if (stream.ReadByte() == 0x5d) { stream.Position += 4L; preloadData.exportSize = stream.ReadInt32(); stream.Position -= 8L; } else { preloadData.exportSize = count; } stream.Position += count - 1; } stream.AlignStream(4); this.m_PathName = stream.ReadAlignedString(stream.ReadInt32()); }
public static bool IsBundleDataCompressed(AssetBundleFile bundle) { AssetsFileReader reader = bundle.reader; reader.Position = bundle.bundleHeader6.GetBundleInfoOffset(); MemoryStream blocksInfoStream; AssetsFileReader memReader; int compressedSize = (int)bundle.bundleHeader6.compressedSize; byte[] uncompressedBytes; switch (bundle.bundleHeader6.GetCompressionType()) { case 1: uncompressedBytes = new byte[bundle.bundleHeader6.decompressedSize]; using (MemoryStream mstream = new MemoryStream(reader.ReadBytes(compressedSize))) { MemoryStream decoder = SevenZipHelper.StreamDecompress(mstream, compressedSize); decoder.Read(uncompressedBytes, 0, (int)bundle.bundleHeader6.decompressedSize); decoder.Dispose(); } blocksInfoStream = new MemoryStream(uncompressedBytes); break; case 2: case 3: uncompressedBytes = new byte[bundle.bundleHeader6.decompressedSize]; using (MemoryStream mstream = new MemoryStream(reader.ReadBytes(compressedSize))) { var decoder = new Lz4DecoderStream(mstream); decoder.Read(uncompressedBytes, 0, (int)bundle.bundleHeader6.decompressedSize); decoder.Dispose(); } blocksInfoStream = new MemoryStream(uncompressedBytes); break; default: blocksInfoStream = null; break; } var uncompressedInf = bundle.bundleInf6; if (bundle.bundleHeader6.GetCompressionType() != 0) { using (memReader = new AssetsFileReader(blocksInfoStream)) { memReader.Position = 0; uncompressedInf = new AssetBundleBlockAndDirectoryList06(); uncompressedInf.Read(0, memReader); } } return(uncompressedInf.blockInf.Any(inf => (inf.flags & 0x3f) != 0)); }
///<summary>Decodes a file using SevenZip </summary> private static async Task <SaveMgr.SaveHead> DecodeAsync(string OriPath, string destPath, int head = 2000) { int len = 0; SaveMgr.SaveHead fileHead = await Task.Run(() => GameUlt.GetFileHead(OriPath, out len)); head = len > head ? len : head; await Task.Run(() => SevenZipHelper.Unzip(OriPath, destPath, head)); return(fileHead); }
private static async Task <SaveMgr.SaveHead> DecodeAsync(Stream inStream, Stream outStream, int head = 2000) { int len = 0; var fileHead = GetFileHead(inStream, out len); head = len > head ? len : head; await Task.Run(() => SevenZipHelper.Unzip(inStream, outStream, head)); outStream.Position = 0; return(fileHead); }
private static async Task BuildSaveFileAsync(Stream inStream, Stream outStream, SaveFile.FileHeader header) { var saveHead = new SaveMgr.SaveHead(); saveHead.V = header.Version; saveHead.M = header.Mode; saveHead.Ms = header.Mods; saveHead.U = header.WriteTime; string head = Assets.USecurity.AES.Encrypt(JsonConvert.SerializeObject((object)saveHead), "bh89757"); await Task.Run(() => SevenZipHelper.Zip(inStream, outStream, head)); }
public void JsonCompressionTest() { string jsonString = message.ToJsonString(); byte[] jsonBytes = Encoding.UTF8.GetBytes(jsonString); Debug.Log(jsonString); Debug.Log("uncompressed length: " + jsonBytes.Length); byte[] jsonBytesCompressed = SevenZipHelper.Compress(jsonBytes); Debug.Log("compressed length: " + jsonBytesCompressed.Length); Expect(jsonBytesCompressed.Length, LessThan(jsonBytes.Length)); }
static Assembly ReadAssemblyFromResource(AssemblyName assemblyName) { var resStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(assemblyName.Name.ToLower()); if (resStream == null) { return(null); } var assemblyStream = new BinaryReader(resStream); byte[] data = SevenZipHelper.Decompress(assemblyStream.ReadBytes((int)assemblyStream.BaseStream.Length)); return(Assembly.Load(data)); }
override public byte[] Expand(byte[] inputbuffer, int realsize) { var ret = SevenZipHelper.Decompress(inputbuffer); if (ret.Length != realsize) { System.Console.WriteLine("WARNING! I expected this lzma block to be " + realsize + " byte long, but it is in fact " + ret.Length + " bytes long"); if (ret.Length == inputbuffer.Length) { System.Console.WriteLine("I have the feeling decompression did NOT take place somehow(?)"); } } return(ret); }
private static async Task BuildSaveFileAsync(Stream st, string path, SaveFile.FileHeader header) { SaveMgr.SaveHead saveHead = new SaveMgr.SaveHead(); saveHead.V = header.Version; saveHead.M = header.Mode; saveHead.Ms = header.Mods; saveHead.U = header.WriteTime; string head = Assets.USecurity.AES.Encrypt(JsonConvert.SerializeObject((object)saveHead), "bh89757"); if (IntPtr.Size == 4) { GC.Collect(); } await Task.Run(() => SevenZipHelper.Zip(st, path, head)); }