/// <summary>
/// Compress raw bytes
/// </summary>
/// <param name="compressor">Compressor to extend</param>
/// <param name="data">The data to compress</param>
/// <returns></returns>
public static byte[] Compress(this ICompressor compressor, byte[] data)
{
using (var outputStream = new MemoryStream(data))
{
return compressor.Compress(outputStream);
}
}
public static byte[] GetRawBytes(this Bitmap bitmap, Bitmap.CompressFormat format)
{
//Convert bitmap to byte array
MemoryStream stream = new MemoryStream();
bitmap.Compress(format, 100, stream);
byte[] byteArray = stream.ToArray();
return byteArray;
}
public static void SaveToFile(this Bitmap bitmap, string filePath)
{
using (FileStream stream = new FileStream(filePath, FileMode.Create))
{
bitmap.Compress(Bitmap.CompressFormat.Png, 100, stream);
stream.Flush();
}
}
/// <summary>
/// Compress a string with optional encoding
/// </summary>
/// <param name="compressor">Compressor to extend</param>
/// <param name="text">The text to compress</param>
/// <param name="encoding">The optional encoding to use.</param>
/// <returns></returns>
public static byte[] Compress(this ICompressor compressor, string text, Encoding encoding = null)
{
if (encoding == null) encoding = Encoding.UTF8;
using (var outputStream = new MemoryStream(encoding.GetBytes(text)))
{
return compressor.Compress(outputStream);
}
}
/// <summary>
/// 비동기 방식으로 정보를 <paramref name="compressor"/>로 압축합니다.
/// </summary>
/// <param name="compressor">압축기</param>
/// <param name="input">압축할 내용</param>
/// <returns>압축 작업</returns>
public static Task<byte[]> CompressTask(this ICompressor compressor, byte[] input) {
compressor.ShouldNotBeNull("compressor");
input.ShouldNotBeEmpty("input");
if(IsDebugEnabled)
log.Debug("바이트 배열을 비동기 방식으로 압축합니다...");
return Task.Factory.StartNew(() => compressor.Compress(input));
}
/// <summary>
/// 지정된 문자열을 압축하고, 압축된 데이타를 Base64 인코딩으로 변환하여 반환한다.
/// </summary>
/// <param name="compressor"><see cref="ICompressor"/> 구현 객체</param>
/// <param name="text">압축할 문자열</param>
/// <returns></returns>
public static string CompressString(this ICompressor compressor, string text) {
if(text.IsEmpty())
return string.Empty;
if(IsDebugEnabled)
log.Debug("Compress string is starting... Input=[{0}]", text.EllipsisChar(30));
return compressor.Compress(text.ToBytes(Encoding.UTF8)).Base64Encode();
}
/// <summary>
/// Helper method to turn bmp image into byte array
/// </summary>
public static byte [] ToByteArray (this Bitmap bmp)
{
byte [] bytes = null;
if (bmp != null) {
using (MemoryStream stream = new MemoryStream ()) {
if (bmp.Compress (Bitmap.CompressFormat.Jpeg, 80, stream)) {
bytes = stream.ToArray ();
}
}
}
return bytes;
}
public static void CompressToFile(this byte[] self, string filePath)
{
var compressedArray = self.Compress();
compressedArray.WriteToDisk(filePath);
}
/// <summary>Compress a byte array using specified compression strength.</summary>
public static byte[] Compress(this byte[] source, int startIndex, int length, CompressionStrength strength)
{
return source.Compress(startIndex, length, strength, 0);
}
/// <summary>Compress a byte array using specified compression strength.</summary>
public static byte[] Compress(this byte[] source, CompressionStrength strength)
{
return source.Compress(0, source.Length, strength, 0);
}
/// <summary>Compress a byte array using default compression strength.</summary>
public static byte[] Compress(this byte[] source)
{
return source.Compress(CompressionStrength.DefaultCompression);
}
/// <summary>
/// Compresses a byte array using the specified compression type.
/// </summary>
/// <param name="bytes">The byte array to be compressed.</param>
/// <param name="type">Type of compression to use.</param>
/// <returns>Compressed byte array.</returns>
public static byte[] Compress(this byte[] bytes, CompressionType type)
{
return bytes.Compress(CompressionLevel.Default, type);
}
/// <summary>
/// Compresses a byte array using Zlib.
/// </summary>
/// <param name="bytes">The byte array to be compressed.</param>
/// <param name="level">Amount of compression to use.</param>
/// <returns>Compressed byte array.</returns>
public static byte[] Compress(this byte[] bytes, CompressionLevel level)
{
return bytes.Compress(level, CompressionType.Zlib);
}
/// <summary>
/// Compresses a byte array using Zlib.
/// </summary>
/// <param name="bytes">The byte array to be compressed.</param>
/// <returns>Compressed byte array.</returns>
public static byte[] Compress(this byte[] bytes)
{
return bytes.Compress(CompressionLevel.Default);
}
/// <summary>
/// 비동기 방식으로 지정한 정보를 압축합니다.
/// </summary>
/// <param name="compressor"><see cref="ICompressor"/> 구현 객체</param>
/// <param name="plain">압축할 데이터</param>
/// <returns>압축을 수행하는 Task</returns>
public static Task<byte[]> CompressAsync(this ICompressor compressor, byte[] plain) {
return Task.Factory.StartNew(() => compressor.Compress(plain));
}
/// <summary>Compress a stream using specified compression strength</summary>
/// <remarks>
/// This returns a memory stream of the compressed results, if the incoming stream is
/// very large this will consume a large amount memory. In this case use the overload
/// that takes the destination stream as a parameter instead.
/// </remarks>
/// <param name="source">The <see cref="Stream"/> to compress.</param>
/// <param name="strength">The <see cref="CompressionStrength"/> of the compression.</param>
/// <returns>Returns a <see cref="MemoryStream"/> of the compressed <see cref="Stream"/>.</returns>
public static MemoryStream Compress(this Stream source, CompressionStrength strength)
{
MemoryStream destination = new MemoryStream();
source.Compress(destination, strength, null);
return destination;
}
/// <summary>
/// Compress a byte array using standard compression method.
/// </summary>
/// <param name="source">The <see cref="Byte"/> array to compress.</param>
/// <returns>A compressed version of the source <see cref="Byte"/> array.</returns>
public static byte[] Compress(this byte[] source)
{
return source.Compress(CompressionStrength.Standard);
}
public static byte[] Compress(this byte[] uncompressed)
{
return uncompressed.Compress(6); // The default compression level, with a good balance of speed and compression efficiency.
}
/// <summary>
/// 스트림을 압축한다.
/// </summary>
/// <param name="compressor"><see cref="ICompressor"/> 구현 객체</param>
/// <param name="stream">압축할 <see cref="Stream"/></param>
/// <returns>압축된 <see cref="MemoryStream"/></returns>
public static Stream CompressStream(this ICompressor compressor, Stream stream) {
return new MemoryStream(compressor.Compress(stream.ToBytes()));
}
