/// <summary>
/// Helper class for compress en decompress of file data
/// </summary>
public static class ZipStreamHelper {
 #region Compress and encode
 /// <summary>
 /// Comprimeer een string en geeft deze terug in Base64 string.
 /// </summary>
 /// <param name="content">filecontent</param>
 /// <returns>gecomprimeerde string</returns>
 public static string CompressToBase64String(string content) {
   //string to byte[]
   byte[] contentArray = stringToByteArray(content);
   // Compress
   byte[] compressed = Compress(contentArray);
   return base64_encode(compressed);
  }

 /// <summary>
 /// Zet een string om naar een ByteArray
 /// </summary>
 /// <param name="content">filecontent</param>
 /// <returns>ByteArray</returns>
 public static byte[] stringToByteArray(string content) {
    System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
   return encoding.GetBytes(content);
  }

 /// <summary>
 /// comprimeer een ByteArray
 /// </summary>
 /// <param name="data">filedata als ByteArray</param>
 /// <returns>gecomprimeerde ByteArray</returns>
 public static byte[] Compress(byte[] data) {
    using(var compressedStream = new MemoryStream())
    using(var zipStream = new GZipStream(compressedStream, CompressionMode.Compress)) {
      zipStream.Write(data, 0, data.Length);
      zipStream.Close();
     return compressedStream.ToArray();
    }
  }

 /// <summary>
 /// Zet een ByteArray om naar een Base64 string
 /// </summary>
 /// <param name="data">gecomprimeerde ByteArray</param>
 /// <returns>Base 64 string</returns>
 public static string base64_encode(byte[] data) {
   if (data == null)
     return string.Empty;
   return Convert.ToBase64String(data);
  }

 /// <summary>
 /// Zet een string om naar een Base64 string
 /// </summary>
 /// <param name="data">string</param>
 /// <returns>Base 64 string</returns>
 public static string string_base64_encode(string data) {
   if (string.IsNullOrEmpty(data))
     return string.Empty;

   //string to byte[]
   byte[] contentArray = stringToByteArray(data);
   return base64_encode(contentArray);
  }
 #endregion

 #region Decompress and decode
 // Decode and decompress
 /// <summary>
 /// Decomprimeer een Base64 string naar een string
 /// </summary>
 /// <param name="contentBase64">GZIP Base64 string</param>
 /// <returns>string</returns>
 public static string DecompressBase64StringToString(string contentBase64) {
   // Decompress
   byte[] decoded = base64_decode(contentBase64);
   byte[] decompressed = Decompress(decoded);

   return byteArrayTostring(decompressed);
  }

 /// <summary>
 /// Zet een ByteArray om in een normale string
 /// </summary>
 /// <param name="data">ByteArray</param>
 /// <returns>string</returns>
 public static string byteArrayTostring(byte[] data) {
    System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
   return enc.GetString(data);
  }

 /// <summary>
 /// Zet een Base64 string om naar een ByteArray
 /// </summary>
 /// <param name="encodedData">Base64 string</param>
 /// <returns>gecomprimeerde ByteArray</returns>
 public static byte[] base64_decode(string encodedData) {
   byte[] encodedDataAsBytes = Convert.FromBase64String(encodedData);
   return encodedDataAsBytes;
  }

 /// <summary>
 /// Zet een gecomprimeerde ByteArray om in een ByteArray
 /// </summary>
 /// <param name="data">gecomprimeerde ByteArray</param>
 /// <returns>ByteArray (gedecomprimeerd)</returns>
 public static byte[] Decompress(byte[] data) {
    using(var compressedStream = new MemoryStream(data))
    using(var zipStream = new GZipStream(compressedStream, CompressionMode.Decompress))
    using(var resultStream = new MemoryStream()) {
     var buffer = new byte[4096];
     int read;

     while ((read = zipStream.Read(buffer, 0, buffer.Length)) > 0) {
        resultStream.Write(buffer, 0, read);
      }

     return resultStream.ToArray();
    }
  }
 #endregion
}