/// <summary> /// 压缩文件夹 /// </summary> /// <param name="dirToZip"></param> /// <param name="zipedFileName"></param> /// <param name="compressionLevel">压缩率0(无压缩)9(压缩率最高)</param> public void ZipDir(string dirToZip, string zipedFileName, int compressionLevel = 9) { if (Path.GetExtension(zipedFileName) != ".zip") { zipedFileName = zipedFileName + ".zip"; } using (var zipoutputstream = new ZipOutputStream(File.Create(zipedFileName))) { zipoutputstream.SetLevel(compressionLevel); var crc = new Crc32(); var fileList = GetAllFies(dirToZip); foreach (DictionaryEntry item in fileList) { var fs = new FileStream(item.Key.ToString(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite); var buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); // ZipEntry entry = new ZipEntry(item.Key.ToString().Substring(dirToZip.Length + 1)); var entry = new ZipEntry(Path.GetFileName(item.Key.ToString())) { DateTime = (DateTime) item.Value, Size = fs.Length }; fs.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; zipoutputstream.PutNextEntry(entry); zipoutputstream.Write(buffer, 0, buffer.Length); } } }
public RuntimeInfo(CompressionMethod method, int compressionLevel, int size, string password, bool getCrc) { this.method = method; this.compressionLevel = compressionLevel; this.password = password; this.size = size; this.random = false; original = new byte[Size]; if (random) { System.Random rnd = new Random(); rnd.NextBytes(original); } else { for (int i = 0; i < size; ++i) { original[i] = (byte)'A'; } } if (getCrc) { Crc32 crc32 = new Crc32(); crc32.Update(original, 0, size); crc = crc32.Value; } }
public void AddStream(string fileName, Stream stream) { if (_zipOutputStream == null) _zipOutputStream = new ZipOutputStream(File.Open(path, FileMode.OpenOrCreate, FileAccess.ReadWrite)); // // Create a CRC value that identifies the file // var crc = new Crc32(); crc.Reset(); crc.Update((int)stream.Length); // // Create a Zip Entry // var zipEntry = new ZipEntry(fileName); zipEntry.DateTime = DateTime.Now; zipEntry.Size = stream.Length; zipEntry.Crc = crc.Value; // // Attach the Zip Entry in ZipFile // _zipOutputStream.PutNextEntry(zipEntry); Pump(stream, _zipOutputStream); _zipOutputStream.CloseEntry(); _zipOutputStream.Flush(); }
public void create_zip(string path, string filename, string type) { string fileNew; // Try fileNew = (filename + ".zip"); //string f; string[] fname = Directory.GetFiles(path, type); ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipoutputstream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create((path + fileNew))); zipoutputstream.SetLevel(6); ICSharpCode.SharpZipLib.Checksums.Crc32 objcrc32 = new ICSharpCode.SharpZipLib.Checksums.Crc32(); foreach (string f in fname) { FileStream stream = File.OpenRead(f); byte[] buff = new byte[stream.Length]; ICSharpCode.SharpZipLib.Zip.ZipEntry zipentry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(f.Substring((f.LastIndexOf("\\") + 1))); //stream.Read(buff, 0, buff.Length); stream.Read(buff, 0, buff.Length); zipentry.DateTime = DateTime.UtcNow.AddHours(5.5); zipentry.Size = stream.Length; stream.Close(); objcrc32.Reset(); objcrc32.Update(buff); // zipentry.Crc = objcrc32.Value; zipoutputstream.PutNextEntry(zipentry); zipoutputstream.Write(buff, 0, buff.Length); } zipoutputstream.Flush(); zipoutputstream.Finish(); zipoutputstream.Close(); }
/// <summary> /// 递归压缩文件 /// </summary> /// <param name="sourceFilePath">待压缩的文件或文件夹路径</param> /// <param name="zipStream">打包结果的zip文件路径(类似 D:\WorkSpace\a.zip),全路径包括文件名和.zip扩展名</param> /// <param name="staticFile"></param> private static void CreateZipFiles(string sourceFilePath, ZipOutputStream zipStream, string staticFile) { Crc32 crc = new Crc32(); string[] filesArray = Directory.GetFileSystemEntries(sourceFilePath); foreach (string file in filesArray) { if (Directory.Exists(file)) //如果当前是文件夹,递归 { CreateZipFiles(file, zipStream, staticFile); } else //如果是文件,开始压缩 { FileStream fileStream = File.OpenRead(file); byte[] buffer = new byte[fileStream.Length]; fileStream.Read(buffer, 0, buffer.Length); string tempFile = file.Substring(staticFile.LastIndexOf("\\") + 1); ZipEntry entry = new ZipEntry(tempFile); entry.DateTime = DateTime.Now; entry.Size = fileStream.Length; fileStream.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; zipStream.PutNextEntry(entry); zipStream.Write(buffer, 0, buffer.Length); } } }
public void CreateZipFile(string[] straFilenames, string strOutputFilename) { Crc32 crc = new Crc32(); ZipOutputStream zos = new ZipOutputStream(File.Create(strOutputFilename)); zos.SetLevel(m_nCompressionLevel); foreach (string strFileName in straFilenames) { FileStream fs = File.OpenRead(strFileName); byte[] buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); ZipEntry entry = new ZipEntry(GetFileNameWithoutDrive(strFileName)); entry.DateTime = DateTime.Now; entry.Size = fs.Length; fs.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; zos.PutNextEntry(entry); zos.Write(buffer, 0, buffer.Length); } zos.Finish(); zos.Close(); }
private void zip(string strFile, ZipOutputStream s, string staticFile) { if (strFile[strFile.Length - 1] != Path.DirectorySeparatorChar) strFile += Path.DirectorySeparatorChar; Crc32 crc = new Crc32(); string[] filenames = Directory.GetFileSystemEntries(strFile); foreach (string file in filenames) { if (Directory.Exists(file)) { zip(file, s, staticFile); } else // 否则直接压缩文件 { //打开压缩文件 FileStream fs = File.OpenRead(file); byte[] buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); string tempfile = file.Substring(staticFile.LastIndexOf("\\") + 1); ZipEntry entry = new ZipEntry(tempfile); entry.DateTime = DateTime.Now; entry.Size = fs.Length; fs.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; s.PutNextEntry(entry); s.Write(buffer, 0, buffer.Length); } } }
//public static void ZipFile(string path, string file2Zip, string zipFileName, string zip, string bldgType) public static void ZipFile(string path, string file2Zip, string zipFileName) { //MemoryStream ms = InitializeGbxml(path + file2Zip, zip, bldgType) as MemoryStream; MemoryStream ms = InitializeGbxml(Path.Combine(path , file2Zip)) as MemoryStream; string compressedFile =Path.Combine(path, zipFileName); if (File.Exists(compressedFile)) { File.Delete(compressedFile); } Crc32 objCrc32 = new Crc32(); ZipOutputStream strmZipOutputStream = new ZipOutputStream(File.Create(compressedFile)); strmZipOutputStream.SetLevel(9); byte[] gbXmlBuffer = new byte[ms.Length]; ms.Read(gbXmlBuffer, 0, gbXmlBuffer.Length); ZipEntry objZipEntry = new ZipEntry(file2Zip); objZipEntry.DateTime = DateTime.Now; objZipEntry.Size = ms.Length; ms.Close(); objCrc32.Reset(); objCrc32.Update(gbXmlBuffer); objZipEntry.Crc = objCrc32.Value; strmZipOutputStream.PutNextEntry(objZipEntry); strmZipOutputStream.Write(gbXmlBuffer, 0, gbXmlBuffer.Length); strmZipOutputStream.Finish(); strmZipOutputStream.Close(); strmZipOutputStream.Dispose(); }
/// <summary> /// 压缩文件 /// </summary> /// <param name="sourceFilePath">待压缩的文件或文件夹路径</param> /// <param name="destinationZipFilePath">保存压缩文件的文件名</param> /// <param name="level">压缩文件等级</param> /// <returns>返回-2说明被压缩文件已经存在,返回1说明压缩成功</returns> public static int CreateFileZip(string sourceFilePath, string destinationZipFilePath, int level) { if (!Directory.Exists(destinationZipFilePath.Substring(0, destinationZipFilePath.LastIndexOf("\\")))) { Directory.CreateDirectory(destinationZipFilePath.Substring(0, destinationZipFilePath.LastIndexOf("\\"))); } if (File.Exists(destinationZipFilePath)) { return -2; } else { ZipOutputStream zipStream = new ZipOutputStream(File.Create(destinationZipFilePath)); zipStream.SetLevel(level); // 压缩级别 0-9 Crc32 crc = new Crc32(); FileStream fileStream = File.OpenRead(sourceFilePath); byte[] buffer = new byte[fileStream.Length]; fileStream.Read(buffer, 0, buffer.Length); string tempFile = sourceFilePath.Substring(sourceFilePath.LastIndexOf("\\") + 1); ZipEntry entry = new ZipEntry(tempFile); entry.DateTime = DateTime.Now; entry.Size = fileStream.Length; fileStream.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; zipStream.PutNextEntry(entry); zipStream.Write(buffer, 0, buffer.Length); zipStream.Finish(); zipStream.Close(); return 1; } }
public static void Zip(string strFile, string strZipFile) { Crc32 crc1 = new Crc32(); ZipOutputStream stream1 = new ZipOutputStream(File.Create(strZipFile)); try { stream1.SetLevel(6); FileStream stream2 = File.OpenRead(strFile); byte[] buffer1 = new byte[stream2.Length]; stream2.Read(buffer1, 0, buffer1.Length); ZipEntry entry1 = new ZipEntry(strFile.Split(new char[] { '\\' })[strFile.Split(new char[] { '\\' }).Length - 1]); entry1.DateTime = DateTime.Now; entry1.Size = stream2.Length; stream2.Close(); crc1.Reset(); crc1.Update(buffer1); entry1.Crc = crc1.Value; stream1.PutNextEntry(entry1); stream1.Write(buffer1, 0, buffer1.Length); } catch (Exception exception1) { throw exception1; } finally { stream1.Finish(); stream1.Close(); stream1 = null; crc1 = null; } }
public static string AddZip(string fileName, string zipName, ZipOutputStream s) { Crc32 crc = new Crc32(); try { FileStream fs = File.OpenRead(fileName); byte[] buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); fileName = Path.GetFileName(fileName); long fileLength = fs.Length; fs.Close(); ZipEntry entry = new ZipEntry(zipName); entry.DateTime = DateTime.Now; entry.Size = fileLength; crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; s.PutNextEntry(entry); s.Write(buffer, 0, buffer.Length); return string.Empty; } catch (Exception addEx) { return addEx.ToString(); } }
private static void ZipFileDirectory(string[] files, ZipOutputStream z) { FileStream fs = null; Crc32 crc = new Crc32(); try { foreach(string file in files) { fs = File.OpenRead(file); byte[] buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); string fileName = Path.GetFileName(file); ZipEntry entry = new ZipEntry(fileName); entry.DateTime = DateTime.Now; entry.Size = fs.Length; fs.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; z.PutNextEntry(entry); z.Write(buffer, 0, buffer.Length); } } finally { if(fs!=null) { fs.Close(); fs = null; } GC.Collect(); } }
/// <summary> /// 在压缩文件中创建一个新的空文件 /// </summary> /// <param name="fileName"></param> /// <param name="fileSize"></param> public void AddFile(string fileName, long fileSize) { crc = new Crc32(); crc.Reset(); entry = new ZipEntry(fileName); entry.DateTime = DateTime.Now; entry.Size = fileSize; zipStream.PutNextEntry(entry); }
/// <summary> /// 将多个文件压缩成一个文件 /// </summary> /// <param name="source">多个文件,采用全路径,例:e:\tmp\tmp1\DD.cs</param> /// <param name="descZip">目标ZIP文件路径</param> /// <param name="password">密码</param> public void File(string[] source, string descZip, string password = null) { ZipOutputStream outStream = new ZipOutputStream(System.IO.File.Create(descZip)); if (!password.IsNullEmpty()) outStream.Password = password; Crc32 crc = new Crc32(); foreach (string info in source) { File(info, crc, outStream); } outStream.Finish(); outStream.Close(); }
public ZipOutputStream(Stream baseOutputStream, int bufferSize) : base(baseOutputStream, new Deflater(-1, true), bufferSize) { this.entries = new ArrayList(); this.crc = new Crc32(); this.defaultCompressionLevel = -1; this.curMethod = CompressionMethod.Deflated; this.zipComment = new byte[0]; this.crcPatchPos = -1L; this.sizePatchPos = -1L; this.useZip64_ = ICSharpCode.SharpZipLib.Zip.UseZip64.Dynamic; }
internal void AddZipEntryToZipOutputStream(ZipOutputStream zipOutputStream, string content, string zipEntryName) { byte[] xmlBytes = m_encoding.GetBytes(content); ZipEntry zipEntry = new ZipEntry(zipEntryName); zipEntry.Size = xmlBytes.Length; zipEntry.DateTime = DateTime.Now; Crc32 crc = new Crc32(); crc.Reset(); crc.Update(xmlBytes); zipEntry.Crc = crc.Value; zipOutputStream.PutNextEntry(zipEntry); zipOutputStream.Write(xmlBytes, 0, xmlBytes.Length); zipOutputStream.CloseEntry(); }
public static bool Compress(string FileName, string ZipFileName) { ZipOutputStream stream; FileStream stream2; if (ZipFileName == "") { ZipFileName = FileName + ".zip"; } Crc32 crc = new Crc32(); try { stream = new ZipOutputStream(System.IO.File.Create(ZipFileName)); } catch { return false; } stream.SetLevel(6); try { stream2 = System.IO.File.OpenRead(FileName); } catch { stream.Finish(); stream.Close(); System.IO.File.Delete(ZipFileName); return false; } byte[] buffer = new byte[stream2.Length]; stream2.Read(buffer, 0, buffer.Length); ZipEntry entry = new ZipEntry(FileName.Split(new char[] { '\\' })[FileName.Split(new char[] { '\\' }).Length - 1]); entry.DateTime = DateTime.Now; entry.Size = stream2.Length; stream2.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; stream.PutNextEntry(entry); stream.Write(buffer, 0, buffer.Length); stream.Finish(); stream.Close(); return true; }
public void ZipFileMain(string[] args) { string[] filenames = Directory.GetFiles(args[0]); Crc32 crc = new Crc32(); ZipOutputStream s = new ZipOutputStream(File.Create(args[1])); s.SetLevel(6); // 0 - store only to 9 - means best compression foreach (string file in filenames) { //打开压缩文件 FileStream fs = File.OpenRead(file); byte[] buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); ZipEntry entry = new ZipEntry(file); entry.DateTime = DateTime.Now; // set Size and the crc, because the information // about the size and crc should be stored in the header // if it is not set it is automatically written in the footer. // (in this case size == crc == -1 in the header) // Some ZIP programs have problems with zip files that don't store // the size and crc in the header. entry.Size = fs.Length; fs.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; s.PutNextEntry(entry); s.Write(buffer, 0, buffer.Length); } s.Finish(); s.Close(); }
/// <summary> /// 压缩文件 /// </summary> /// <param name="fileName">要压缩的所有文件(完全路径)</param> /// <param name="fileName">文件名称</param> /// <param name="name">压缩后文件路径</param> /// <param name="Level">压缩级别</param> public static void ZipFileMain(string[] filenames, string[] fileName, string name, int Level) { #region MyRegion ZipOutputStream s = new ZipOutputStream(File.Create(name)); Crc32 crc = new Crc32(); //压缩级别 s.SetLevel(Level); // 0 - store only to 9 - means best compression try { int m = 0; foreach (string file in filenames) { //打开压缩文件 FileStream fs = File.OpenRead(file);//文件地址 byte[] buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); //建立压缩实体 ZipEntry entry = new ZipEntry(fileName[m].ToString());//原文件名 //时间 entry.DateTime = DateTime.Now; //空间大小 entry.Size = fs.Length; fs.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; s.PutNextEntry(entry); s.Write(buffer, 0, buffer.Length); m++; } } catch { throw; } finally { s.Finish(); s.Close(); } #endregion }
/// <summary> /// Производит компрессию указанного потока. Сжатые данные добавляются в конец /// выходного потока. /// </summary> /// <param name="fileName">Имя файла (записи в ZIP-потоке).</param> /// <param name="srcStream">Поток данных для сжатия.</param> public void WriteFile( string fileName, Stream srcStream ) { byte[] buffer = new byte[srcStream.Length]; srcStream.Read( buffer, 0, buffer.Length ); // контрольная сумма Crc32 crc = new Crc32(); crc.Reset(); crc.Update( buffer ); // добавить запись о файле в результирующий поток ZipEntry entry = new ZipEntry( fileName ); entry.DateTime = DateTime.Now; entry.Size = srcStream.Length; entry.Crc = crc.Value; m_zipStream.PutNextEntry( entry ); // сжать и записать буфер данных в результирующий поток m_zipStream.Write( buffer, 0, buffer.Length ); }
/// <summary> /// 功能:压缩一个文件,不包含路径信息 /// </summary> /// <param name="strSrcFile">待压缩文件</param> /// <param name="crc">CRC校验</param> /// <param name="outStream"></param> private void File(string source, Crc32 crc, ZipOutputStream outStream) { string strFileName = Path.GetFileName(source); // 文件名,不含路径信息 #region 读取文件信息 FileStream fs = System.IO.File.OpenRead(source); long iLength = fs.Length;// 文件长度 byte[] buffer = new byte[iLength]; fs.Read(buffer, 0, buffer.Length); fs.Close(); #endregion ZipEntry entry = new ZipEntry(strFileName); entry.CompressionMethod = CompressionMethod.Deflated; // deflate entry.DateTime = DateTime.Now; entry.Size = iLength; #region CRC校验 crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; #endregion outStream.PutNextEntry(entry); outStream.Write(buffer, 0, buffer.Length); }
protected override void _Unir(string fichero, string dirDest) { CutterTail tailInicial = CutterTail.LoadFromFile (fichero); if (tailInicial != null) { string destino = dirDest + Path.DirectorySeparatorChar + tailInicial.Original; long total = tailInicial.FileSize; long transferidos = 0; Stream fos = UtilidadesFicheros.CreateWriter (destino); string ficheroBase = fichero.Substring (0, fichero.Length - 1); int contador = 1; CutterTail tail = null; byte[] buffer = new byte[Consts.BUFFER_LENGTH]; OnProgress (0, total); Crc32 crc = new Crc32 (); while ((tail = CutterTail.LoadFromFile (ficheroBase + contador)) != null) { int leidos = 0; int parcial = 0; long fileSize = new FileInfo (ficheroBase + contador).Length; FileStream fis = File.OpenRead (ficheroBase + contador); crc.Reset (); while ((leidos = fis.Read (buffer, 0, Math.Min ((int)fileSize - CutterTail.TAIL_SIZE - parcial, buffer.Length))) > 0) { fos.Write (buffer, 0, leidos); crc.Update (buffer, 0, leidos); parcial += leidos; transferidos += leidos; } fis.Close (); if (crc.Value != tail.Crc) { throw new Dalle.Formatos.ChecksumVerificationException ("checksum failed on file " + contador, ficheroBase + contador ); } contador++; } fos.Close(); } }
// ------------------------------------------------------------------ /// <summary> /// Compress a folder with multiple files and subfolders with /// the ZIP algorithm. Use the DecompressFolder() routine to /// decompress the compressed bytes. /// </summary> /// <param name="folderPath">The path to the folder /// that will be compressed.</param> /// <returns>Returns the compressed folder contents.</returns> public static byte[] CompressFolder( string folderPath ) { if ( folderPath == null || folderPath.Length <= 0 ) { return null; } else { using ( MemoryStream buf = new MemoryStream() ) using ( ZipOutputStream zip = new ZipOutputStream( buf ) ) { Crc32 crc = new Crc32(); zip.SetLevel( 9 ); // 0..9. DoCompressFolder( buf, zip, crc, folderPath, folderPath ); zip.Finish(); // -- byte[] c = new byte[buf.Length]; buf.Seek( 0, SeekOrigin.Begin ); buf.Read( c, 0, c.Length ); // -- zip.Close(); return c; } } }
/// <summary> /// Compress a byte array with the ZIP algorithm. /// Use the DecompressBytes() routine to decompress the compressed bytes. /// </summary> /// <param name="input">The bytes to compress.</param> /// <returns>Returns the compressed bytes.</returns> public static byte[] CompressBytes( byte[] input) { using (MemoryStream buf = new MemoryStream()) using (ZipOutputStream zip = new ZipOutputStream(buf)) { Crc32 crc = new Crc32(); zip.SetLevel(9); // 0..9. ZipEntry entry = new ZipEntry(string.Empty); entry.DateTime = DateTime.Now; entry.Size = input.Length; crc.Reset(); crc.Update(input); entry.Crc = crc.Value; zip.PutNextEntry(entry); zip.Write(input, 0, input.Length); zip.Finish(); // -- byte[] c = new byte[buf.Length]; buf.Seek(0, SeekOrigin.Begin); buf.Read(c, 0, c.Length); // -- zip.Close(); return c; } }
public static void ZipFileDictory(string[] args) { string[] files = Directory.GetFiles(args[0]); Crc32 crc32 = new Crc32(); ZipOutputStream zipOutputStream = new ZipOutputStream((Stream) File.Create(args[1])); zipOutputStream.SetLevel(6); foreach (string str in files) { FileStream fileStream = File.OpenRead(str); byte[] buffer = new byte[fileStream.Length]; fileStream.Read(buffer, 0, buffer.Length); ZipEntry entry = new ZipEntry(str); entry.DateTime = DateTime.Now; entry.Size = fileStream.Length; fileStream.Close(); crc32.Reset(); crc32.Update(buffer); entry.Crc = crc32.Value; zipOutputStream.PutNextEntry(entry); zipOutputStream.Write(buffer, 0, buffer.Length); } zipOutputStream.Finish(); zipOutputStream.Close(); }
/// <summary> /// ZipFileMain /// </summary> /// <param name="args"></param> public static void ZipFileMain(string[] args) { string[] filenames = Directory.GetFiles(args[0]); Crc32 crc = new Crc32(); ZipOutputStream s = new ZipOutputStream(File.Create(args[1])); s.SetLevel(6); // 0 - store only to 9 - means best compression foreach (string file in filenames) { FileStream fs = File.OpenRead(file); byte[] buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); ZipEntry entry = new ZipEntry(file); entry.DateTime = DateTime.Now; entry.Size = fs.Length; fs.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; s.PutNextEntry(entry); s.Write(buffer, 0, buffer.Length); } s.Finish(); s.Close(); }
/// <summary> /// Internal private hashing method. /// /// This is the new hashing algorithm from other clients. /// Found to be fast and have very good distribution. /// </summary> /// <param name="key"></param> /// <returns></returns> private static int NewCompatHashingAlg(string key) { Crc32 checksum = new Crc32(); checksum.Update(UTF8Encoding.UTF8.GetBytes(key)); int crc = (int) checksum.Value; return (crc >> 16) & 0x7fff; }
public static byte[] ZipMultiFiles(int CompressLevel, bool isWithoutFilePathInfo, params string[] FileNames) { ZipOutputStream stream = null; FileStream stream2 = null; MemoryStream baseOutputStream = new MemoryStream(); bool flag = false; try { Crc32 crc = new Crc32(); stream = new ZipOutputStream(baseOutputStream); stream.SetLevel(CompressLevel); foreach (string str in FileNames) { if (System.IO.File.Exists(str)) { stream2 = System.IO.File.OpenRead(str); byte[] buffer = new byte[stream2.Length]; stream2.Read(buffer, 0, buffer.Length); stream2.Close(); crc.Reset(); crc.Update(buffer); ZipEntry entry = new ZipEntry(isWithoutFilePathInfo ? Path.GetFileName(str) : str); entry.DateTime = DateTime.Now; entry.Size = buffer.Length; entry.Crc = crc.Value; stream.PutNextEntry(entry); stream.Write(buffer, 0, buffer.Length); } } flag = true; } catch { } finally { if (stream2 != null) { stream2.Close(); } if (stream != null) { stream.Finish(); stream.Close(); } } byte[] buffer2 = null; if (flag) { buffer2 = baseOutputStream.GetBuffer(); } return buffer2; }
/// <summary> /// Closes the zip input stream /// </summary> public override void Close() { base.Close(); crc = null; entry = null; }
/// <summary> /// Builds the update and stores it in the system's database. /// </summary> /// <returns>True if the operation succeeds, false otherwise.</returns> private bool AddUpdate() { bool retVal = false; try { byte [] buffer = new byte[0]; FileStream ifs = null; FileInfo fi = null; MemoryStream oms = new MemoryStream(); Crc32 crc = new Crc32(); ZipOutputStream zs = new ZipOutputStream(oms); int numFiles = lstFiles.Items.Count; for(int i = 0; i<numFiles ; i++) { string entryName = Path.GetFileName(lstFiles.Items[i].SubItems[0].Text); fi = new FileInfo(lstFiles.Items[i].SubItems[0].Text); ifs = File.OpenRead(lstFiles.Items[i].SubItems[0].Text); buffer = new byte[fi.Length]; ifs.Read(buffer, 0, buffer.Length); ZipEntry entry = new ZipEntry(entryName); entry.DateTime = fi.LastWriteTime; entry.Size = fi.Length; crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; zs.PutNextEntry(entry); zs.Write(buffer, 0, buffer.Length); prgProgress.Value = (int)(((i+1)*80)/numFiles); } zs.Finish(); zs.Close(); buffer = oms.ToArray(); oms.Close(); //Connect to the database SqlConnection dbcon = null; try { dbcon = new SqlConnection(globals.ProvideConnectionString()); dbcon.Open(); } catch(Exception ex) { if(dbcon != null) { dbcon.Dispose(); dbcon = null; } throw ex; } prgProgress.Value = 85; SqlCommand cmd = new SqlCommand("cw_insert_client_update", dbcon); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.Add("@client_update_version", SqlDbType.Char, 15); cmd.Parameters.Add("@client_update_image", SqlDbType.Image); Version latestVersion = new Version(txtNewVersion.Text); cmd.Parameters[0].Value = latestVersion.ToString(); cmd.Parameters[1].Value = buffer; prgProgress.Value = 90; cmd.ExecuteNonQuery(); dbcon.Close(); prgProgress.Value = 100; lblLatestVersionVal.Text = latestVersion.ToString(); retVal = true; } catch(Exception e) { globals.Log.LogError("CrawlWave.ServerManager failed to create an update: " + e.ToString()); MessageBox.Show(this.Text + " failed to create and update:\n" + e.Message); retVal = false; } finally { GC.Collect(); } return retVal; }
private void CreateZipFile(string img_quality) { string[] filenames = Directory.GetFiles(SubdirPath (img_quality)); Crc32 crc = new Crc32(); ZipOutputStream s = new ZipOutputStream(File.Create(SubdirPath ("zip", img_quality + ".zip"))); s.SetLevel(0); foreach (string file in filenames) { FileStream fs = File.OpenRead(file); byte[] buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); ZipEntry entry = new ZipEntry(Path.GetFileName(file)); entry.DateTime = DateTime.Now; // set Size and the crc, because the information // about the size and crc should be stored in the header // if it is not set it is automatically written in the footer. // (in this case size == crc == -1 in the header) // Some ZIP programs have problems with zip files that don't store // the size and crc in the header. entry.Size = fs.Length; fs.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; s.PutNextEntry(entry); s.Write(buffer, 0, buffer.Length); } s.Finish(); s.Close(); }