C# Use Zip Archives without External Libraries

using System;
using System.Collections.Generic;
using System.Text;

using System.IO;
using System.Linq;
using System.Reflection;

// add ref to PresentationCore.dll for System.IO.Packaging
// add ref to WindowsBase.dll for System.IO.Packaging.Package


namespace codeproject.ZipArchive {


   /// <summary>
   /// This is a .NET 3.5 adaptation of Code Project article
   /// 'C# Use Zip Archives without External Libraries'
   /// http://www.codeproject.com/Articles/209731/Csharp-use-Zip-archives-without-external-libraries
   /// by  D. Christian Ohle
   /// </summary>
   /// <remarks>
   /// Only minor changes were needed:
   /// - set references to PresentationCore.dll and WindowsBase.dll
   /// - added ZipArchive(object) constructor
   /// - added ZipFileInfo(object) constructor
   /// - added additional OpenOnFile(), OpenOnStream(), AddFile()
   ///   to support function polymorphism. .NET 3.5 does not support default values for optional parameters by default
   /// - added CopyTo() method
   /// - calls of ZipArchive()-, ZipFileInfo()-constructors adjusted
   /// </remarks>
   public class ZipArchive : IDisposable {
      private object external;

      public enum CompressionMethodEnum { 
         Stored, 
         Deflated 
      };
      public enum DeflateOptionEnum { 
         Normal, 
         Maximum, 
         Fast, 
         SuperFast 
      };

      private ZipArchive() {
      }

      /// <remarks>
      /// added for .NET 3.5 support
      /// </remarks>
      private ZipArchive(object external) {
         this.external = external;
      }

      public static ZipArchive OpenOnFile(string path, FileMode mode, FileAccess access, FileShare share, bool streaming) {
         var type = typeof(System.IO.Packaging.Package).Assembly.GetType("MS.Internal.IO.Zip.ZipArchive");
         var meth = type.GetMethod("OpenOnFile", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
         return new ZipArchive(meth.Invoke(null, new object[] { path, mode, access, share, streaming }));
      }

      public static ZipArchive OpenOnFile(string path) {
         return ZipArchive.OpenOnFile(path, FileMode.Open, FileAccess.Read, FileShare.Read, false);
      }

      public static ZipArchive OpenOnStream(Stream stream) {
         return ZipArchive.OpenOnStream(stream, FileMode.OpenOrCreate, FileAccess.ReadWrite, false);
      }

      public static ZipArchive OpenOnStream(Stream stream, FileMode mode, FileAccess access, bool streaming) {
         var type = typeof(System.IO.Packaging.Package).Assembly.GetType("MS.Internal.IO.Zip.ZipArchive");
         var meth = type.GetMethod("OpenOnStream", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
         return new ZipArchive(meth.Invoke(null, new object[] { stream, mode, access, streaming }));
      }

      public ZipFileInfo AddFile(string path) {
         return this.AddFile(path, CompressionMethodEnum.Deflated, DeflateOptionEnum.Normal);
      }

      public ZipFileInfo AddFile(string path, CompressionMethodEnum compmeth, DeflateOptionEnum option) {
         var type = external.GetType();
         var meth = type.GetMethod("AddFile", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
         var comp = type.Assembly.GetType("MS.Internal.IO.Zip.CompressionMethodEnum").GetField(compmeth.ToString()).GetValue(null);
         var opti = type.Assembly.GetType("MS.Internal.IO.Zip.DeflateOptionEnum").GetField(option.ToString()).GetValue(null);
         return new ZipFileInfo(meth.Invoke(external, new object[] { path, comp, opti }));
      }

      public void DeleteFile(string name) {
         var meth = external.GetType().GetMethod("DeleteFile", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
         meth.Invoke(external, new object[] { name });
      }

      public void Dispose() {
         ((IDisposable)external).Dispose();
      }
      public ZipFileInfo GetFile(string name) {
         var meth = external.GetType().GetMethod("GetFile", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
         return new ZipFileInfo(meth.Invoke(external, new object[] { name }));
      }

      public IEnumerable<ZipFileInfo> Files {
         get {
            var meth = external.GetType().GetMethod("GetFiles", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            var coll = meth.Invoke(external, null) as System.Collections.IEnumerable; //ZipFileInfoCollection
            foreach (var p in coll) yield return new ZipFileInfo(p);
         }
      }

      public IEnumerable<string> FileNames {
         get {
            return Files.Select(p => p.Name).OrderBy(p => p);
         }
      }

      /// <summary>
      /// 
      /// </summary>
      /// <param name="input"></param>
      /// <param name="output"></param>
      /// <remarks>
      /// added for .NET 3.5 support
      /// </remarks>
      public static void CopyTo(Stream input, Stream output) {
         byte[] buffer = new byte[16 * 1024]; // Fairly arbitrary size
         int bytesRead;

         while ((bytesRead = input.Read(buffer, 0, buffer.Length)) > 0) {
            output.Write(buffer, 0, bytesRead);
         }
      }

      public struct ZipFileInfo {
         internal object external;

         /// <summary>
         /// 
         /// </summary>
         /// <param name="external"></param>
         /// <remarks>
         /// added for .NET 3.5 support
         /// </remarks>
         internal ZipFileInfo(object external) {
            this.external = external;
         }

         private object GetProperty(string name) {
            return external.GetType().GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(external, null);
         }

         public override string ToString() {
            return Name;// base.ToString();
         }

         public string Name {
            get { return (string)GetProperty("Name"); }
         }

         public DateTime LastModFileDateTime {
            get { return (DateTime)GetProperty("LastModFileDateTime"); }
         }

         public bool FolderFlag {
            get { return (bool)GetProperty("FolderFlag"); }
         }

         public bool VolumeLabelFlag {
            get { return (bool)GetProperty("VolumeLabelFlag"); }
         }

         public object CompressionMethod {
            get { return GetProperty("CompressionMethod"); }
         }

         public object DeflateOption {
            get { return GetProperty("DeflateOption"); }
         }

         public Stream GetStream() {
            return this.GetStream(FileMode.Open, FileAccess.Read);
         }

         public Stream GetStream(FileMode mode, FileAccess access) {
            var meth = external.GetType().GetMethod("GetStream", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            return (Stream)meth.Invoke(external, new object[] { mode, access });
         }

      } // struct ZipFileInfo
   } // class ZipArchive
} // namepace

private void testCreateZip() {
   string newZip = @"E:\Temp\Tests\Tests.zip";
   using (var zip = ZipArchive.OpenOnFile(newZip, FileMode.Create, FileAccess.ReadWrite, FileShare.None, false)) {
      var fs = zip.AddFile(@"FolderA\FileA.txt");
      var str = fs.GetStream(FileMode.Open, FileAccess.ReadWrite);
      var input = new FileStream(@"E:\Temp\Tests\FolderA\FileA.txt", FileMode.Open);
      ZipArchive.CopyTo(input, str);
      str.Dispose();

      fs = zip.AddFile(@"FolderB\FileB.txt");
      str = fs.GetStream(FileMode.Open, FileAccess.ReadWrite);
      input = new FileStream(@"E:\Temp\Tests\FolderB\FileB.txt", FileMode.Open);
      ZipArchive.CopyTo(input, str);
      str.Dispose();
   }
}

private void testReadZip() {
   string existingZip = @"E:\Temp\links.zip";
   using (var zip = ZipArchive.OpenOnFile(existingZip)) {
      listBox1.Items.AddRange(zip.Files.OrderBy(file => file.Name).Select(file => file.Name).ToArray());
   }
}

files = folder.GetFiles("*.*");
foreach (FileInfo file in files)
{
    ///DO SOMETHING
    //AddFileToZip(zipFileName, file.FullName, folder);
    using (var str = new FileStream(zipFileName, FileMode.OpenOrCreate))
    {

        using (var arc = ZipArchive.OpenOnStream(str, FileMode.OpenOrCreate, FileAccess.ReadWrite, false))
        {
            //var fs = str.AddFile("C:\\Server.TXT", ZipArchive.CompressionMethodEnum.Deflated, ZipArchive.DeflateOptionEnum.Normal);
            var fs = arc.AddFile(file.FullName, ZipArchive.CompressionMethodEnum.Deflated, ZipArchive.DeflateOptionEnum.Normal);
            using (var fsstr = fs.GetStream(FileMode.Open, FileAccess.Read))
            {
                CopyStream(fsstr, str);
            }
        }
    }