/// <summary> /// Compress multiple items with the ZIP algorithm. /// </summary> /// <param name="infos">The items to compress.</param> /// <param name="progress1">The progress1.</param> /// <param name="progress2">The progress2.</param> /// <param name="destinationStream">The destination stream.</param> /// <returns></returns> private static Stream CompressHeterogenousToStream( CompressHeterogenousInfos infos, ICancelableProgress progress1, Cancelable progress2, Stream destinationStream ) { if ( infos == null || infos.InternalItems == null || infos.InternalItems.Count <= 0 ) { return null; } else { // No "using" block. ZipOutputStream zip = new ZipOutputStream( destinationStream ); Crc32 crc = new Crc32(); zip.SetLevel( 9 ); // 0..9. int index = 1; foreach ( CompressHeterogenousInfo info in infos.InternalItems ) { // Cancel, if requested. if ( progress1 != null ) { if ( progress1.OnProgress( null, EventArgs.Empty ) == CancelMode.Cancel ) { return null; } } // Cancel, if requested. if ( progress2 != null ) { if ( progress2( info ) == CancelMode.Cancel ) { return null; } } // -- byte[] buffer = null; string fileName = null; bool putEntry; switch ( info.Type ) { case CompressHeterogenousInfo.InfoType.String: fileName = info.FilePath; if ( fileName == null || fileName.Length <= 0 ) { fileName = string.Format( @"file{0}.bin", index ); } buffer = Encoding.UTF8.GetBytes( info.Content ); putEntry = true; break; case CompressHeterogenousInfo.InfoType.File: fileName = Path.GetFileName( info.FilePath ); ZipEntry entry = new ZipEntry( fileName ); zip.PutNextEntry( entry ); using ( FileStream fs = new FileStream( info.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read ) ) using ( BinaryReader r = new BinaryReader( fs ) ) { byte[] smallBuffer = new byte[16384]; int bytesRead; do { bytesRead = r.Read( smallBuffer, 0, smallBuffer.Length ); zip.Write( smallBuffer, 0, bytesRead ); // -- // Cancel, if requested. if ( progress1 != null ) { if ( progress1.OnProgress( null, EventArgs.Empty ) == CancelMode.Cancel ) { return null; } } // Cancel, if requested. if ( progress2 != null ) { if ( progress2( info ) == CancelMode.Cancel ) { return null; } } } while ( bytesRead > 0 ); } putEntry = false; break; case CompressHeterogenousInfo.InfoType.Bytes: fileName = info.FilePath; if ( fileName == null || fileName.Length <= 0 ) { fileName = string.Format( @"file{0}.bin", index ); } buffer = info.Bytes; putEntry = true; break; default: Debug.Assert( false, string.Format( @"Unknown compression info type '{0}'.", info.Type ) ); putEntry = false; break; } // -- if ( putEntry ) { ZipEntry entry = new ZipEntry( fileName ); entry.DateTime = DateTime.Now; entry.Size = buffer.Length; crc.Reset(); crc.Update( buffer ); entry.Crc = crc.Value; zip.PutNextEntry( entry ); zip.Write( buffer, 0, buffer.Length ); } index++; } zip.Finish(); return zip; } }
/// <summary> /// Compress multiple items with the ZIP algorithm. /// </summary> /// <param name="infos">The items to compress.</param> /// <returns>Returns the compressed items.</returns> public static byte[] CompressHeterogenous( CompressHeterogenousInfos infos ) { if ( infos == null || infos.InternalItems == null || infos.InternalItems.Count <= 0 ) { return null; } else { using ( MemoryStream buf = new MemoryStream() ) using ( ZipOutputStream zip = new ZipOutputStream( buf ) ) { Crc32 crc = new Crc32(); zip.SetLevel( 9 ); // 0..9. int index = 1; foreach ( CompressHeterogenousInfo info in infos.InternalItems ) { byte[] buffer = null; string fileName = null; switch ( info.Type ) { case CompressHeterogenousInfo.InfoType.String: { fileName = info.FilePath; if ( fileName == null || fileName.Length <= 0 ) { fileName = string.Format( @"file{0}.bin", index ); } buffer = Encoding.UTF8.GetBytes( info.Content ); } break; case CompressHeterogenousInfo.InfoType.File: { using ( FileStream fs = new FileStream( info.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read ) ) using ( BinaryReader r = new BinaryReader( fs ) ) { buffer = new byte[fs.Length]; fs.Read( buffer, 0, buffer.Length ); fileName = Path.GetFileName( info.FilePath ); } } break; case CompressHeterogenousInfo.InfoType.Bytes: { fileName = info.FilePath; if ( fileName == null || fileName.Length <= 0 ) { fileName = string.Format( @"file{0}.bin", index ); } buffer = info.Bytes; } break; default: Debug.Assert( false, string.Format( @"Unknown compression info type '{0}'.", info.Type ) ); break; } ZipEntry entry = new ZipEntry( fileName ); entry.DateTime = DateTime.Now; entry.Size = buffer.Length; crc.Reset(); crc.Update( buffer ); entry.Crc = crc.Value; zip.PutNextEntry( entry ); zip.Write( buffer, 0, buffer.Length ); index++; } 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 multiple items with the ZIP algorithm. /// </summary> /// <param name="infos">The items to compress.</param> /// <param name="progress1">The progress1.</param> /// <param name="progress2">The progress2.</param> /// <param name="destinationFilePath">The destination file path.</param> private static void CompressHeterogenousToFile( CompressHeterogenousInfos infos, ICancelableProgress progress1, Cancelable progress2, FileInfo destinationFilePath ) { if ( destinationFilePath.Exists ) { destinationFilePath.Delete(); } using ( FileStream destinationStream = new FileStream( destinationFilePath.FullName, FileMode.OpenOrCreate, FileAccess.ReadWrite ) ) { Stream realStream = CompressHeterogenousToStream( infos, progress1, progress2, destinationStream ); if ( realStream != null ) { realStream.Dispose(); } } }
/// <summary> /// Compress multiple items with the ZIP algorithm. /// </summary> /// <param name="infos">The items to compress.</param> /// <param name="progress">The progress.</param> /// <param name="destinationFilePath">The destination file path.</param> public static void CompressHeterogenousToFile( CompressHeterogenousInfos infos, Cancelable progress, FileInfo destinationFilePath ) { CompressHeterogenousToFile( infos, null, progress, destinationFilePath ); }
/// <summary> /// Compress multiple items with the ZIP algorithm. /// </summary> /// <param name="infos">The items to compress.</param> /// <param name="progress1">The progress1.</param> /// <param name="progress2">The progress2.</param> /// <returns>Returns the compressed items.</returns> private static byte[] CompressHeterogenous( CompressHeterogenousInfos infos, ICancelableProgress progress1, Cancelable progress2 ) { using ( MemoryStream destinationStream = new MemoryStream() ) { Stream realStream = CompressHeterogenousToStream( infos, progress1, progress2, destinationStream ); if ( realStream == null ) { return null; } else { using ( realStream ) { byte[] c = new byte[destinationStream.Length]; destinationStream.Seek( 0, SeekOrigin.Begin ); destinationStream.Read( c, 0, c.Length ); return c; } } } }
/// <summary> /// Compress multiple items with the ZIP algorithm. /// </summary> /// <param name="infos">The items to compress.</param> /// <param name="progress">The progress.</param> /// <returns>Returns the compressed items.</returns> public static byte[] CompressHeterogenous( CompressHeterogenousInfos infos, Cancelable progress ) { return CompressHeterogenous( infos, null, progress ); }
/// <summary> /// Compress multiple items with the ZIP algorithm. /// </summary> /// <param name="infos">The items to compress.</param> /// <returns>Returns the compressed items.</returns> public static byte[] CompressHeterogenous( CompressHeterogenousInfos infos ) { return CompressHeterogenous( infos, null, null ); }