C# Use Zip Archives without External Libraries

Type reflectedType = external.GetType();
PropertyInfo propInfo = reflectedType.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
MethodInfo methodInfo = reflectedType.GetMethod("GetStream", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

propInfo.GetValue(external, null);

methodInfo.Invoke(external, ...);

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());
         }
      }