Zipping using System.IO.Compression

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Packaging;
 
public static class ZipHelper
{
    public static void ZipFiles(string path, IEnumerable files, CompressionOption compressionLevel = CompressionOption.Normal)
    {
        using (FileStream fileStream = new FileStream(path, FileMode.Create))
        {
            ZipHelper.ZipFilesToStream(fileStream, files, compressionLevel);
        }
    }
 
    public static byte[] ZipFilesToByteArray(IEnumerable files, CompressionOption compressionLevel = CompressionOption.Normal)
    {
        MemoryStream memoryStream = default(MemoryStream);
        using (memoryStream = new MemoryStream())
        {
            ZipHelper.ZipFilesToStream(memoryStream, files, compressionLevel);
        }
 
        return memoryStream.ToArray();
    }
 
    public static void Unzip(string zipPath, string baseFolder)
    {
        using (FileStream fileStream = new FileStream(zipPath, FileMode.Open))
        {
            ZipHelper.UnzipFilesFromStream(fileStream, baseFolder);
        }
    }
 
    public static void UnzipFromByteArray(byte[] zipData, string baseFolder)
    {
        using (MemoryStream memoryStream = new MemoryStream(zipData))
        {
            ZipHelper.UnzipFilesFromStream(memoryStream, baseFolder);
        }
    }
 
    private static void ZipFilesToStream(Stream destination, IEnumerable files, CompressionOption compressionLevel)
    {
        using (Package package = Package.Open(destination, FileMode.Create))
        {
            foreach (string path in files)
            {
                Uri fileUri = new Uri(@"/" + Path.GetFileName(path), UriKind.Relative);
                string contentType = @"data/" + ZipHelper.GetFileExtentionName(path);
 
                using (Stream zipStream = package.CreatePart(fileUri, contentType, compressionLevel).GetStream())
                {
                    using (FileStream fileStream = new FileStream(path, FileMode.Open))
                    {
                        ZipHelper.CopyStream(fileStream, zipStream);
                    }
                }
            }
        }
    }
 
    private static void UnzipFilesFromStream(Stream source, string baseFolder)
    {
        if (!Directory.Exists(baseFolder))
        {
            Directory.CreateDirectory(baseFolder);
        }
 
        using (Package package = Package.Open(source, FileMode.Open))
        {
            foreach (PackagePart zipPart in package.GetParts())
            {
                string path = Path.Combine(baseFolder, zipPart.Uri.ToString().Substring(1));
 
                using (Stream zipStream = zipPart.GetStream())
                {
                    using (FileStream fileStream = new FileStream(path, FileMode.Create))
                    {
                        ZipHelper.CopyStream(zipStream, fileStream);
                    }
                }
            }
        }
    }
 
    private static void CopyStream(Stream source, Stream destination)
    {
        const int bufferSize = 0x1000;
        byte[] buffer = new byte[bufferSize];
        int count = 0;
 
        while ((count = source.Read(buffer, 0, bufferSize)) > 0)
        {
            destination.Write(buffer, 0, count);
        }
    }
 
    private static string GetFileExtentionName(string path)
    {
        string extention = Path.GetExtension(path);
        if (!string.IsNullOrWhiteSpace(extention) && extention.StartsWith("."))
        {
            extention = extention.Substring(1);
        }
 
        return extention;
    }
}