/// <summary> /// This function creates a zip /// </summary> /// <param name="filepaths">List of absolute system filepaths</param> /// <param name="zipFileName">Absolute desired systeme final zip filepath</param> /// <param name="compressionLevel">Compression level from 0 (no comp.) to 9 (best comp.)</param> /// <returns></returns> public StdResult<NoType> CreateZip(List<string> filepaths, string zipFileName, int compressionLevel) { try { using (ZipOutputStream s = new ZipOutputStream(File.Create(zipFileName))) { s.SetLevel(9); // 0 - store only to 9 - means best compression byte[] buffer = new byte[4096]; foreach (string file in filepaths) { // Using GetFileName makes the result compatible with XP // as the resulting path is not absolute. ZipEntry entry = new ZipEntry(Path.GetFileName(file)); // Setup the entry data as required. // Crc and size are handled by the library for seakable streams // so no need to do them here. // Could also use the last write time or similar for the file. entry.DateTime = DateTime.Now; s.PutNextEntry(entry); using (FileStream fs = File.OpenRead(file)) { // Using a fixed size buffer here makes no noticeable difference for output // but keeps a lid on memory usage. int sourceBytes; do { sourceBytes = fs.Read(buffer, 0, buffer.Length); s.Write(buffer, 0, sourceBytes); } while (sourceBytes > 0); } } // Finish/Close arent needed strictly as the using statement does this automatically // Finish is important to ensure trailing information for a Zip file is appended. Without this // the created file would be invalid. s.Finish(); // Close is important to wrap things up and unlock the file. s.Close(); return StdResult<NoType>.OkResult; } } catch (Exception ex) { return StdResult<NoType>.BadResult(ex.Message); // No need to rethrow the exception as for our purposes its handled. } }
/// <summary> /// Zip all the specified files into the specified ZipFileName. /// </summary> public static string ZipFiles(IEnumerable<string> FilesToZip, string ZipFileName, string Password) { if (!File.Exists(ZipFileName)) File.Delete(ZipFileName); ZipOutputStream Zip = new ZipOutputStream(File.Create(ZipFileName)); if (Password != "") Zip.Password = Password; try { Zip.SetLevel(5); // 0 - store only to 9 - means best compression foreach (string FileName in FilesToZip) { FileStream fs = File.OpenRead(FileName); byte[] Buffer = new byte[fs.Length]; fs.Read(Buffer, 0, Buffer.Length); fs.Close(); ZipEntry Entry = new ZipEntry(Path.GetFileName(FileName)); Zip.PutNextEntry(Entry); Zip.Write(Buffer, 0, Buffer.Length); } Zip.Finish(); Zip.Close(); return ZipFileName; } catch (System.Exception) { Zip.Finish(); Zip.Close(); File.Delete(ZipFileName); throw; } }
public void zip(string to, string[] files) { using (ZipOutputStream s = new ZipOutputStream(File.Create(to))) { s.SetLevel(9); byte[] buffer = new byte[4096]; foreach (string file in files) { ZipEntry entry = new ZipEntry(Path.GetFileName(file)) { DateTime = DateTime.Now }; s.PutNextEntry(entry); using (FileStream fs = File.OpenRead(file)) { int sourceBytes; do { sourceBytes = fs.Read(buffer, 0, buffer.Length); s.Write(buffer, 0, sourceBytes); } while (sourceBytes > 0); } } s.Finish(); s.Close(); } }
private void saveFileDialog_FileOk(object sender, CancelEventArgs e) { ReportText = ReportTextBox.Text; ZipEntry ze; ZipOutputStream zip_out = new ZipOutputStream(File.Create((sender as SaveFileDialog).FileName)); string SourceText; byte[] data=null; foreach (string FileName in FileNames) { SourceText = VEC.StandartCompiler.GetSourceFileText(FileName); if (SourceText != null) { data = System.Text.Encoding.GetEncoding(1251).GetBytes(SourceText); ze = new ZipEntry(System.IO.Path.GetFileName(FileName)); zip_out.PutNextEntry(ze); zip_out.Write(data, 0, data.Length); } } ze = new ZipEntry("Report.txt"); zip_out.PutNextEntry(ze); data = System.Text.Encoding.GetEncoding(1251).GetBytes(ReportText); zip_out.Write(data, 0, data.Length); zip_out.Finish(); zip_out.Close(); }
public static void ZipFile(IEnumerable<string> InputFilePath, string outputPathAndFile, string password) { string outPath = outputPathAndFile; ZipOutputStream oZipStream = new ZipOutputStream(File.Create(outPath)); foreach (string FilePath in InputFilePath) { int TrimLength = 0; if (Path.GetDirectoryName(FilePath) != null) { TrimLength = (Path.GetDirectoryName(FilePath)).Length; TrimLength += 1; //remove '\' } if (!string.IsNullOrEmpty(password)) oZipStream.Password = password; oZipStream.SetLevel(9); // maximum compression ZipFile(TrimLength, oZipStream, FilePath); } oZipStream.Finish(); oZipStream.Close(); }
public void ZipFile(string FileToZip, string ZipedFile, int CompressionLevel, int BlockSize) { if (!File.Exists(FileToZip)) { throw new FileNotFoundException("The specified file " + FileToZip + " could not be found. Zipping aborderd"); } FileStream fileStream = new FileStream(FileToZip, FileMode.Open, FileAccess.Read); FileStream baseOutputStream = File.Create(ZipedFile); ZipOutputStream zipOutputStream = new ZipOutputStream(baseOutputStream); ZipEntry entry = new ZipEntry("ZippedFile"); zipOutputStream.PutNextEntry(entry); zipOutputStream.SetLevel(CompressionLevel); byte[] array = new byte[BlockSize]; int num = fileStream.Read(array, 0, array.Length); zipOutputStream.Write(array, 0, num); try { while ((long)num < fileStream.Length) { int num2 = fileStream.Read(array, 0, array.Length); zipOutputStream.Write(array, 0, num2); num += num2; } } catch (Exception ex) { throw ex; } zipOutputStream.Finish(); zipOutputStream.Close(); fileStream.Close(); }
//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(); }
public byte[] diskLess() { MemoryStream ms = new MemoryStream(); StreamWriter sw = new StreamWriter(ms); sw.WriteLine("HELLO!"); sw.WriteLine("I WANT TO SAVE THIS FILE AS A .TXT FILE WITHIN TWO FOLDERS"); sw.Flush(); //This is required or you get a blank text file :) ms.Position = 0; // create the ZipEntry archive from the txt file in memory stream ms MemoryStream outputMS = new System.IO.MemoryStream(); ZipOutputStream zipOutput = new ZipOutputStream(outputMS); ZipEntry ze = new ZipEntry(@"dir1/dir2/whatever.txt"); zipOutput.PutNextEntry(ze); zipOutput.Write(ms.ToArray(), 0, Convert.ToInt32(ms.Length)); zipOutput.Finish(); zipOutput.Close(); byte[] byteArrayOut = outputMS.ToArray(); outputMS.Close(); ms.Close(); return byteArrayOut; }
public override void ExecuteResult(ControllerContext context) { string fileName = Path.GetTempFileName(); var response = context.HttpContext.Response; using (var zipOutputStream = new ZipOutputStream(new FileStream(fileName, FileMode.OpenOrCreate))) { zipOutputStream.SetLevel(0); foreach (var photo in Photos) { //FileInfo fileInfo = new FileInfo(photo.MediaFilePath); ZipEntry entry = new ZipEntry(Tag.Name + @"\" + photo.Id + ".jpg"); zipOutputStream.PutNextEntry(entry); using (FileStream fs = System.IO.File.OpenRead(photo.MediaFilePath)) { byte[] buff = new byte[1024]; int n = 0; while ((n = fs.Read(buff, 0, buff.Length)) > 0) zipOutputStream.Write(buff, 0, n); } } zipOutputStream.Finish(); } System.IO.FileInfo file = new System.IO.FileInfo(fileName); response.Clear(); response.AddHeader("Content-Disposition", "attachment; filename=" + "Photos.zip"); response.AddHeader("Content-Length", file.Length.ToString()); response.ContentType = "application/octet-stream"; response.WriteFile(file.FullName); response.End(); System.IO.File.Delete(fileName); }
public static string PackToBase64(byte[] data) { byte[] buffer; MemoryStream ms = new MemoryStream(); using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(ms)) { zipOutputStream.SetLevel(9); ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry("Boliglag.Admin"); zipOutputStream.PutNextEntry(zipEntry); zipOutputStream.Write(data, 0, data.Length); zipOutputStream.Flush(); zipOutputStream.Finish(); buffer = new byte[ms.Length]; ms.Position = 0; ms.Read(buffer, 0, Convert.ToInt32(ms.Length)); }//using ( ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream( fileStreamOut ) ) ... return(ToBase64(buffer)); }
public static string PackToBase64(string text) { byte[] buffer; MemoryStream ms = new MemoryStream(); using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(ms)) { zipOutputStream.SetLevel(9); ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry("Boliglag.Admin"); zipOutputStream.PutNextEntry(zipEntry); byte[] bytes = System.Text.Encoding.Unicode.GetBytes(text.ToCharArray()); zipOutputStream.Write(bytes, 0, bytes.Length); zipOutputStream.Flush(); zipOutputStream.Finish(); buffer = new byte[ms.Length]; ms.Position = 0; ms.Read(buffer, 0, Convert.ToInt32(ms.Length)); }//using ( ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream( fileStreamOut ) ) ... return(ToBase64(buffer)); }
public static string GetZipFileName(string filename) { string zipfile = filename.Replace (".db", ".zip"); try { using (ZipOutputStream s = new ZipOutputStream (File.Create (zipfile))) { s.SetLevel (9); // 0 - store only to 9 - means best compression byte[] buffer = new byte[4096]; ZipEntry entry = new ZipEntry (filename); entry.DateTime = DateTime.Now; s.PutNextEntry (entry); using (FileStream fs = File.OpenRead (filename)) { int sourceBytes; do { sourceBytes = fs.Read (buffer, 0, buffer.Length); s.Write (buffer, 0, sourceBytes); } while (sourceBytes > 0); } s.Finish (); s.Close (); } } catch (Exception ex) { zipfile = filename; } return zipfile; }
private void CompressFiles(IEnumerable<string> filePaths, ZipOutputStream zipStream) { foreach (var fullFileName in filePaths) { var fi = new FileInfo(fullFileName); var fileName = Path.GetFileName(fullFileName); var newEntry = new ZipEntry(fileName) {DateTime = fi.LastWriteTime, Size = fi.Length}; // Note the zip format stores 2 second granularity // Specifying the AESKeySize triggers AES encryption. Allowable values are 0 (off), 128 or 256. // A password on the ZipOutputStream is required if using AES. // newEntry.AESKeySize = 256; // To permit the zip to be unpacked by built-in extractor in WinXP and Server2003, WinZip 8, Java, and other older code, // you need to do one of the following: Specify UseZip64.Off, or set the Size. // If the file may be bigger than 4GB, or you do not need WinXP built-in compatibility, you do not need either, // but the zip will be in Zip64 format which not all utilities can understand. // zipStream.UseZip64 = UseZip64.Off; zipStream.UseZip64 = UseZip64.Off; zipStream.PutNextEntry(newEntry); // Zip the file in buffered chunks // the "using" will close the stream even if an exception occurs var buffer = new byte[4096]; using (var streamReader = File.OpenRead(fullFileName)) { StreamUtils.Copy(streamReader, zipStream, buffer); } zipStream.CloseEntry(); } zipStream.Finish(); }
static public void CompressFolder(string aFolderName, string aFullFileOuputName, string[] ExcludedFolderNames, string[] ExcludedFileNames){ // Perform some simple parameter checking. More could be done // like checking the target file name is ok, disk space, and lots // of other things, but for a demo this covers some obvious traps. if (!Directory.Exists(aFolderName)) { Debug.Log("Cannot find directory : " + aFolderName); return; } try { string[] exFileNames = new string[0]; string[] exFolderNames = new string[0]; if(ExcludedFileNames != null) exFileNames = ExcludedFileNames; if(ExcludedFolderNames != null) exFolderNames = ExcludedFolderNames; // Depending on the directory this could be very large and would require more attention // in a commercial package. List<string> filenames = GenerateFolderFileList(aFolderName, null); //foreach(string filename in filenames) Debug.Log(filename); // 'using' statements guarantee the stream is closed properly which is a big source // of problems otherwise. Its exception safe as well which is great. using (ZipOutputStream zipOut = new ZipOutputStream(File.Create(aFullFileOuputName))){ zipOut.Finish(); zipOut.Close(); } using(ZipFile s = new ZipFile(aFullFileOuputName)){ s.BeginUpdate(); int counter = 0; //add the file to the zip file foreach(string filename in filenames){ bool include = true; string entryName = filename.Replace(aFolderName, ""); //Debug.Log(entryName); foreach(string fn in exFolderNames){ Regex regEx = new Regex(@"^" + fn.Replace(".",@"\.")); if(regEx.IsMatch(entryName)) include = false; } foreach(string fn in exFileNames){ Regex regEx = new Regex(@"^" + fn.Replace(".",@"\.")); if(regEx.IsMatch(entryName)) include = false; } if(include){ s.Add(filename, entryName); } counter++; } //commit the update once we are done s.CommitUpdate(); //close the file s.Close(); } } catch(Exception ex) { Debug.Log("Exception during processing" + ex.Message); // No need to rethrow the exception as for our purposes its handled. } }
public void CreateFxz() { using (var zipStream = new ZipOutputStream(File.Create(GetTemporaryDirectory() + "foo.fxz"))) { _zipStream = zipStream; zipStream.SetLevel(9); string filename = "content.fxd"; string fullpath = GetFullPath(filename); var ms = File.Create(fullpath); _streamWriter = new StreamWriter(ms); WriteContent(); ms.Close(); AddFileToZip(fullpath); RemoveTemporaryFile(fullpath); _streamWriter.Flush(); zipStream.Finish(); zipStream.Close(); } }
/// <summary> /// Compresses an array of bytes and stores the result in a new array of bytes. /// </summary> /// <param name="uncompressed">The uncompressed buffer.</param> /// <param name="compressed">An array of bytes where the compressed input will be stored.</param> /// <remarks> /// The compressed input is passed back to the calling method as an <b>out</b> /// parameter. That means that the calling method doesn't need to initialize the /// compressed buffer. /// </remarks> /// <exception cref="ArgumentNullException"> /// Thrown if the uncompressed input buffer is empty or null. /// </exception> /// <exception cref="CWZipException"> /// Thrown if a problem is encountered during the compression process. /// </exception> public static void CompressBuffer(byte[] uncompressed, out byte[] compressed) { if ((uncompressed == null) || (uncompressed.Length == 0)) { throw new ArgumentNullException("uncompressed", "The uncompressed input buffer cannot be null or empty."); } MemoryStream ms = null; compressed = null; try { ms = new MemoryStream(); ZipOutputStream zip = new ZipOutputStream(ms); zip.SetLevel(compressionLevel); ZipEntry entry = new ZipEntry("1"); zip.PutNextEntry(entry); zip.Write(uncompressed, 0, uncompressed.Length); zip.Finish(); ms.Position = 0; compressed = ms.ToArray(); ms.Close(); } catch (Exception e) { if (ms != null) { ms.Close(); } throw new CWZipException(e.Message); } finally { ms = null; GC.Collect(); } }
/// <summary> /// Método que faz o zip de arquivos encontrados no diretório <strPathDirectory> /// </summary> /// <param name="strPath"></param> public static void ZipFiles(String strPathDirectory, String strZipName) { try { using (ZipOutputStream ZipOut = new ZipOutputStream(File.Create(strPathDirectory + "\\" + strZipName + ".zip"))) { string[] OLfiles = Directory.GetFiles(strPathDirectory); Console.WriteLine(OLfiles.Length); ZipOut.SetLevel(9); byte[] buffer = new byte[4096]; foreach (string filename in OLfiles) { ZipEntry entry = new ZipEntry(Path.GetFileName(filename)); ZipOut.PutNextEntry(entry); using (FileStream fs = File.OpenRead(filename)) { int sourceBytes; do { sourceBytes = fs.Read(buffer, 0, buffer.Length); ZipOut.Write(buffer, 0, sourceBytes); } while (sourceBytes > 0); } } ZipOut.Finish(); ZipOut.Close(); } } catch (System.Exception ex) { System.Console.Error.WriteLine("exception: " + ex); //TODO colocar log } }
/// <summary> /// Creates a bundle containing version list delta and all data of files. /// </summary> /// <returns>The binary bundle.</returns> /// <param name="list">List needed to transferred.</param> public static byte[] CreateFileBundle(List<FileEvent> list) { using (MemoryStream ms = new MemoryStream()) using (ZipOutputStream zip = new ZipOutputStream(ms)) { ZipEntry block = new ZipEntry("vs"); zip.PutNextEntry(block); zip.WriteAllBytes(list.SerializeAsBytes()); zip.CloseEntry(); foreach (var sha1 in list.Where(x => x.SHA1 != null).Select(x => x.SHA1).Distinct()) { block = new ZipEntry(sha1); zip.PutNextEntry(block); zip.WriteAllBytes(File.ReadAllBytes(Config.MetaFolderData.File(sha1))); zip.CloseEntry(); } zip.Finish(); ms.Flush(); ms.Position = 0; return ms.ToArray(); } }
/// <summary> /// 压缩文件 /// </summary> /// <param name="sourcePath">待压缩的目录</param> /// <param name="zipFilePath">待生成的压缩文件</param> public static void CreateZipFile(string sourcePath, string zipFilePath) { if (!Directory.Exists(sourcePath) && !File.Exists(sourcePath)) throw new IOException("找不到目录或文件sourcePath"); if (!zipFilePath.ToLower().EndsWith(".zip")) { zipFilePath += ".zip"; } using (ZipOutputStream s = new ZipOutputStream(File.Create(zipFilePath))) { s.SetLevel(9); // 压缩级别 0-9 //s.Password = "******"; //Zip压缩文件密码 if (Directory.Exists(sourcePath)) AppendZipDirectory(s, null, sourcePath); else if (File.Exists(sourcePath)) AppendZipFile(s, null, sourcePath); s.Finish(); s.Close(); } }
/// <summary> /// Compress an string using ZIP /// </summary> /// <param name="xml"></param> /// <returns></returns> public static byte[] CompressContent(string contentToZip) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); byte[] buff = encoding.GetBytes(contentToZip); try { using (MemoryStream stream = new MemoryStream()) { using (ZipOutputStream zipout = new ZipOutputStream(stream)) { zipout.SetLevel(9); ZipEntry entry = new ZipEntry("zipfile.zip"); entry.DateTime = DateTime.Now; zipout.PutNextEntry(entry); zipout.Write(buff, 0, buff.Length); zipout.Finish(); byte[] outputbyte = new byte[(int)stream.Length]; stream.Position = 0; stream.Read(outputbyte, 0, (int)stream.Length); return outputbyte; } } } catch (Exception ex) { ex.Message.ToString(); return null; } }
/// <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; } }
/// <summary> /// Zips the files in the specifed directory and outputs the zip file to the specified location. /// </summary> /// <param name="zipFilePath">The full path to the output zip file.</param> /// <returns>The total number of files added to the zip file.</returns> public int ZipToFile(string zipFilePath) { int total = 0; if (Directory.Exists(DirectoryPath)) { if (!Directory.Exists(Path.GetDirectoryName(zipFilePath))) { Directory.CreateDirectory(Path.GetDirectoryName(zipFilePath)); } // Create the zip file //Crc32 crc = new Crc32(); ZipOutputStream zipFile = new ZipOutputStream(File.Create(zipFilePath)); zipFile.UseZip64 = UseZip64.Off; zipFile.SetLevel(9); total += ZipFromPath(zipFile, DirectoryPath); // Close the writer zipFile.Finish(); zipFile.Close(); } return total; }
public FileResult DownloadAllFiles() { var context = System.Web.HttpContext.Current; var folderPath = context.Server.MapPath("~/UploadedFiles/"); var baseOutputStream = new MemoryStream(); ZipOutputStream zipOutput = new ZipOutputStream(baseOutputStream) {IsStreamOwner = false}; /* * Higher compression level will cause higher usage of reources * If not necessary do not use highest level 9 */ zipOutput.SetLevel(4); SharpZipLibHelper.ZipFolder(folderPath, zipOutput); zipOutput.Finish(); zipOutput.Close(); /* Set position to 0 so that cient start reading of the stream from the begining */ baseOutputStream.Position = 0; /* Set custom headers to force browser to download the file instad of trying to open it */ return new FileStreamResult(baseOutputStream, "application/x-zip-compressed") { FileDownloadName = "eResult.zip" }; }
public static void CreateZipFile(string[] filenames, string outputFile) { // Zip up the files - From SharpZipLib Demo Code using (ZipOutputStream s = new ZipOutputStream(File.Create(outputFile))) { s.SetLevel(9); // 0-9, 9 being the highest level of compression byte[] buffer = new byte[4096]; foreach (string file in filenames) { ZipEntry entry = new ZipEntry(Path.GetFileName(file)); entry.DateTime = DateTime.Now; s.PutNextEntry(entry); using (FileStream fs = File.OpenRead(file)) { int sourceBytes; do { sourceBytes = fs.Read(buffer, 0, buffer.Length); s.Write(buffer, 0, sourceBytes); } while (sourceBytes > 0); } } s.Finish(); s.Close(); } }
private void Page_Load(object sender, System.EventArgs e) { System.DateTime dateTime = System.DateTime.Now; string s1 = "Message_Backup_\uFFFD" + dateTime.ToString("ddMMyy_HHmmss\uFFFD") + ".zip\uFFFD"; System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(); ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(memoryStream); ActiveUp.Net.Mail.Mailbox mailbox = ((ActiveUp.Net.Mail.Imap4Client)Session["imapobject\uFFFD"]).SelectMailbox(Request.QueryString["b\uFFFD"]); char[] chArr = new char[] { ',' }; string[] sArr = Request.QueryString["m\uFFFD"].Split(chArr); for (int i = 0; i < sArr.Length; i++) { string s2 = sArr[i]; byte[] bArr = mailbox.Fetch.Message(System.Convert.ToInt32(s2)); ActiveUp.Net.Mail.Header header = ActiveUp.Net.Mail.Parser.ParseHeader(bArr); ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(header.Subject + ".eml\uFFFD"); zipOutputStream.PutNextEntry(zipEntry); zipOutputStream.SetLevel(9); zipOutputStream.Write(bArr, 0, bArr.Length); zipOutputStream.CloseEntry(); } zipOutputStream.Finish(); Response.AddHeader("Content-Disposition\uFFFD", "attachment; filename=\uFFFD" + s1); Response.ContentType = "application/zip\uFFFD"; Response.BinaryWrite(memoryStream.GetBuffer()); zipOutputStream.Close(); }
public static void CompressFiles(IEnumerable<ISong> files, string destinationPath) { if (log.IsDebugEnabled) { log.Debug("Starting creation of zip file : " + destinationPath); } using (ZipOutputStream zipOutputStream = new ZipOutputStream(new FileStream(destinationPath, FileMode.OpenOrCreate))) { zipOutputStream.SetLevel(0); foreach (ISong song in files) { FileInfo fileInfo = new FileInfo(song.MediaFilePath); ZipEntry entry = new ZipEntry(song.Artist.Name + "\\" + song.Album.Name + "\\" + song.Title + fileInfo.Extension); zipOutputStream.PutNextEntry(entry); FileStream fs = File.OpenRead(song.MediaFilePath); byte[] buff = new byte[1024]; int n = 0; while ((n = fs.Read(buff, 0, buff.Length)) > 0) { zipOutputStream.Write(buff, 0, n); } fs.Close(); } zipOutputStream.Finish(); } if (log.IsDebugEnabled) { log.Debug("Zip file created : " + destinationPath); } }
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(); }
public static void CreateFromDirectory(string[] sourceFileNames, string destinationArchiveFileName) { using (ZipOutputStream zipStream = new ZipOutputStream(File.Create(destinationArchiveFileName))) { byte[] buffer = new byte[BufferSize]; zipStream.SetLevel(9); foreach (string file in sourceFileNames) { var entryName = Path.GetFileName(file); var fileInfo = new FileInfo(file); ZipEntry entry = new ZipEntry(entryName); entry.DateTime = fileInfo.LastWriteTime; zipStream.PutNextEntry(entry); using (FileStream fileStream = File.OpenRead(file)) { while (true) { int size = fileStream.Read(buffer, 0, buffer.Length); if (size <= 0) break; zipStream.Write(buffer, 0, size); } } } zipStream.Finish(); zipStream.Close(); } }
public void AddEntryAfterFinish() { MemoryStream ms = new MemoryStream(); ZipOutputStream s = new ZipOutputStream(ms); s.Finish(); s.PutNextEntry(new ZipEntry("dummyfile.tst")); }
public void ZipFile(string FileToZip, string ZipedFile, int CompressionLevel, int BlockSize) { //如果文件没有找到,则报错 if (!System.IO.File.Exists(FileToZip)) { throw new System.IO.FileNotFoundException("The specified file " + FileToZip + " could not be found. Zipping aborderd"); } System.IO.FileStream StreamToZip = new System.IO.FileStream(FileToZip, System.IO.FileMode.Open, System.IO.FileAccess.Read); System.IO.FileStream ZipFile = System.IO.File.Create(ZipedFile); ZipOutputStream ZipStream = new ZipOutputStream(ZipFile); ZipEntry ZipEntry = new ZipEntry("ZippedFile"); ZipStream.PutNextEntry(ZipEntry); ZipStream.SetLevel(CompressionLevel); byte[] buffer = new byte[BlockSize]; System.Int32 size = StreamToZip.Read(buffer, 0, buffer.Length); ZipStream.Write(buffer, 0, size); try { while (size < StreamToZip.Length) { int sizeRead = StreamToZip.Read(buffer, 0, buffer.Length); ZipStream.Write(buffer, 0, sizeRead); size += sizeRead; } } catch (System.Exception ex) { throw ex; } ZipStream.Finish(); ZipStream.Close(); StreamToZip.Close(); }
public void CompressFile(string sourcePath, string destinationPath) { using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create(destinationPath))) { zipStream.SetLevel(9); byte[] buffer = new byte[4096]; ICSharpCode.SharpZipLib.Zip.ZipEntry entry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(System.IO.Path.GetFileName(sourcePath)); entry.DateTime = DateTime.Now; zipStream.PutNextEntry(entry); using (FileStream fs = File.OpenRead(sourcePath)) { int sourceBytes = 0; do { sourceBytes = fs.Read(buffer, 0, buffer.Length); zipStream.Write(buffer, 0, sourceBytes); } while (sourceBytes > 0); } zipStream.Finish(); zipStream.Close(); zipStream.Dispose(); } }
public static void ZipFiles(string inputFolderPath, string outputPathAndFile, string password) { ArrayList ar = GenerateFileList(inputFolderPath); // generate file list int TrimLength = (Directory.GetParent(inputFolderPath)).ToString().Length; // find number of chars to remove // from orginal file path TrimLength += 1; //remove '\' FileStream ostream; byte[] obuffer; string outPath = outputPathAndFile; ZipOutputStream oZipStream = new ZipOutputStream(File.Create(outPath)); // create zip stream if (password != null && password != String.Empty) oZipStream.Password = password; oZipStream.SetLevel(9); // maximum compression ZipEntry oZipEntry; foreach (string Fil in ar) // for each file, generate a zipentry { oZipEntry = new ZipEntry(Fil.Remove(0, TrimLength)); oZipStream.PutNextEntry(oZipEntry); if (!Fil.EndsWith(@"/")) // if a file ends with '/' its a directory { ostream = File.OpenRead(Fil); obuffer = new byte[ostream.Length]; ostream.Read(obuffer, 0, obuffer.Length); oZipStream.Write(obuffer, 0, obuffer.Length); } } oZipStream.Finish(); oZipStream.Close(); oZipStream.Dispose(); }
/// <summary> /// 压缩文件 /// </summary> /// <param name="strFile">压缩源路径</param> /// <param name="strZip">压缩文件保存路径</param> /// <param name = "rootDir">压缩文件根目录</param> /// <param name = "isEndExtent">是否压缩包含扩展名的文件</param> /// <param name = "extents">用于筛选的扩展名</param> public static void ZipFile (string strFile, string strZip, string rootDir = "", bool isEndExtent = false, params string[] extents) { var s = new ZipOutputStream (File.Create (strZip)); s.SetLevel (9); // 0 - store only to 9 - means best compression zip (strFile, s, rootDir, isEndExtent, extents); s.Finish (); s.Close (); }
public static string CreateZIPFile(string path, int M, string strsuff) { try { Crc32 crc = new Crc32();//未压缩的 ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipout = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(System.IO.File.Create(path + ".zip")); //ICSharpCode.SharpZipLib.GZip.GZipOutputStream zipout = new GZipOutputStream(System.IO.File.Create(path+ ".zip")); System.IO.FileStream fs = System.IO.File.OpenRead(path + strsuff); long pai = 1024 * 1024 * M;//每M兆写一次 long forint = fs.Length / pai + 1; byte[] buffer = null; zipout.SetLevel(7); ZipEntry entry = new ZipEntry(System.IO.Path.GetFileName(path + strsuff)); entry.Size = fs.Length; entry.DateTime = DateTime.Now; zipout.PutNextEntry(entry); //zipout. for (long i = 1; i <= forint; i++) { if (pai * i < fs.Length) { buffer = new byte[pai]; fs.Seek(pai * (i - 1), System.IO.SeekOrigin.Begin); } else { if (fs.Length < pai) { buffer = new byte[fs.Length]; } else { buffer = new byte[fs.Length - pai * (i - 1)]; fs.Seek(pai * (i - 1), System.IO.SeekOrigin.Begin); } } fs.Read(buffer, 0, buffer.Length); crc.Reset(); crc.Update(buffer); zipout.Write(buffer, 0, buffer.Length); zipout.Flush(); } fs.Close(); zipout.Finish(); zipout.Close(); System.IO.File.Delete(path + strsuff); // File.Create(path.Replace(".doc","") + ".zip",buffer.Length); return(path + ".zip"); } catch (Exception ex) { string str = ex.Message; return(path); } }
/// <summary> /// 压缩文件(Zip) /// </summary> /// <param name="filesPath">待压缩文件目录</param> /// <param name="zipFilePath">压缩文件输出目录</param> /// <returns></returns> public static ZipInfo CreateZipFile(string filesPath, string zipFilePath) { if (!System.IO.Directory.Exists(filesPath)) { return(new ZipInfo { Success = false, InfoMessage = "没有找到文件" }); } try { string[] filenames = System.IO.Directory.GetFiles(filesPath); using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream s = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create(zipFilePath))) { s.SetLevel(9); // 压缩级别 0-9 //s.Password = "******"; //Zip压缩文件密码 byte[] buffer = new byte[4096]; //缓冲区大小 foreach (string file in filenames) { ICSharpCode.SharpZipLib.Zip.ZipEntry entry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(Path.GetFileName(file)); entry.DateTime = DateTime.Now; s.PutNextEntry(entry); using (FileStream fs = File.OpenRead(file)) { int sourceBytes; do { sourceBytes = fs.Read(buffer, 0, buffer.Length); s.Write(buffer, 0, sourceBytes); } while (sourceBytes > 0); } } s.Finish(); s.Close(); } return(new ZipInfo { Success = true, InfoMessage = "压缩成功" }); } catch (Exception ex) { return(new ZipInfo { Success = false, InfoMessage = ex.Message }); } }
public static Boolean ZipFile(String filePath, String zipFile) { if (!File.Exists(filePath)) { Debug.WriteLine("Cannot find file '{0}'", filePath); return(false); } try { using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create(zipFile))) { zipStream.SetLevel(9); //0~9 byte[] buffer = new byte[4096]; ICSharpCode.SharpZipLib.Zip.ZipEntry entry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(System.IO.Path.GetFileName(filePath)); entry.DateTime = DateTime.Now; zipStream.PutNextEntry(entry); using (FileStream fs = File.OpenRead(filePath)) { int sourceBytes = 0; do { sourceBytes = fs.Read(buffer, 0, buffer.Length); zipStream.Write(buffer, 0, sourceBytes); } while (sourceBytes > 0); } zipStream.Finish(); zipStream.Close(); zipStream.Dispose(); } if (File.Exists(zipFile)) { return(true); } } catch (Exception ex) { Debug.WriteLine("Exception during processing {0}", ex); } return(false); }
private String CompressionDossier(String pFichier) { try { if (Directory.Exists(pFichier) == true) { //System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream(); using (var s = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create(String.Format("{0}.zip", pFichier)))) { s.SetLevel(9); var buffer = new byte[4096]; var entry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(pFichier) { DateTime = DateTime.Now }; s.PutNextEntry(entry); using (StreamReader fs = new StreamReader(pFichier)) { int sourceBytes; do { sourceBytes = fs.Read(); s.Write(buffer, 0, sourceBytes); } while (sourceBytes > 0); } s.Finish(); s.Close(); s.Dispose(); pFichier = string.Format("{0}.zip", pFichier); } //} } return(pFichier); } catch (Exception ex) { throw ex; } }
} // Unpack /// <summary> /// Zip a file. /// </summary> /// <param name="filename"></param> /// <param name="appendZipExtension"></param> public static void PackFile(string filename, bool appendZipExtension) { if (filename == null) { throw new ArgumentNullException("filename"); } if (!File.Exists(filename)) { throw new ArgumentException(string.Format("File does not exist: {0}.", filename), "filename"); } string newFilename = filename + ".zip"; if (!appendZipExtension) { newFilename = Path.GetDirectoryName(filename) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(filename) + ".zip"; } if (File.Exists(newFilename)) { File.Delete(newFilename); } FileStream fileStreamOut = File.Create(newFilename); ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(fileStreamOut); zipOutputStream.SetLevel(9); ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(Path.GetFileName(filename)); zipOutputStream.PutNextEntry(zipEntry); FileStream fileStreamIn = File.OpenRead(filename); const long BUFFER_SIZE = 8192; long currentIndex = 0; byte[] buffer = new byte[BUFFER_SIZE]; if (fileStreamIn.Length <= BUFFER_SIZE) { fileStreamIn.Read(buffer, 0, Convert.ToInt32(fileStreamIn.Length)); zipOutputStream.Write(buffer, 0, Convert.ToInt32(fileStreamIn.Length)); } else { do { long remaining = BUFFER_SIZE; if (currentIndex + BUFFER_SIZE >= fileStreamIn.Length) { remaining = fileStreamIn.Length - currentIndex; } fileStreamIn.Read(buffer, 0, Convert.ToInt32(remaining)); currentIndex += remaining; zipOutputStream.Write(buffer, 0, Convert.ToInt32(remaining)); } while (currentIndex < fileStreamIn.Length); } fileStreamIn.Close(); zipOutputStream.Flush(); zipOutputStream.Finish(); zipOutputStream.Close(); fileStreamOut.Close(); }// ZipFile
}// ZipFile /// <summary> /// Zip multiple files(fileNames) in directory(directory) to (flowName).zip. /// </summary> /// <param name="directory"></param> /// <param name="fileNames"></param> /// <param name="reportName"></param> public static void PackFilesIntoOne(string directory, string[] fileNames, string outputFilename) { if (directory == null) { throw new ArgumentNullException("directory"); } if (fileNames == null) { throw new ArgumentNullException("fileNames"); } if (outputFilename == null) { throw new ArgumentNullException("outputFilename"); } if (fileNames.Length == 0) { throw new ArgumentException("Length cannot be 0.", "fileNames"); } string newFilename = Path.Combine(directory, outputFilename); if (File.Exists(newFilename)) { File.Delete(newFilename); } using (FileStream fileStreamOut = File.Create(newFilename)) { using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(fileStreamOut)) { zipOutputStream.SetLevel(9); foreach (string filename in fileNames) { ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(filename); zipOutputStream.PutNextEntry(zipEntry); using (FileStream fileStreamIn = File.OpenRead(Path.Combine(directory, filename))) { const long BUFFER_SIZE = 8192; long currentIndex = 0; byte[] buffer = new byte[BUFFER_SIZE]; if (fileStreamIn.Length <= BUFFER_SIZE) { fileStreamIn.Read(buffer, 0, Convert.ToInt32(fileStreamIn.Length)); zipOutputStream.Write(buffer, 0, Convert.ToInt32(fileStreamIn.Length)); } else { do { long remaining = BUFFER_SIZE; if (currentIndex + BUFFER_SIZE >= fileStreamIn.Length) { remaining = fileStreamIn.Length - currentIndex; } fileStreamIn.Read(buffer, 0, Convert.ToInt32(remaining)); currentIndex += remaining; zipOutputStream.Write(buffer, 0, Convert.ToInt32(remaining)); } while (currentIndex < fileStreamIn.Length); } } // using ( FileStream fileStreamIn = File.OpenRead( Path.Combine( directory, filename ) ... } // foreach zipOutputStream.Flush(); zipOutputStream.Finish(); } //using ( ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream( fileStreamOut ) ) ... } // using ( FileStream fileStreamOut = File.Create( newFilename ) ... }