What's the best way to implement file compression?

The Answer: DotNetZip

I know it's bad juju to use an answer to post a comment, but I need to show some detail. Please accept my apologies.

Here are the implementation details that were answered by Lucas and confirmed by x4000:

Using DotNetZip version 1.9, place the Ionic.Zip.reduced.dll in your Assets folder.

Then, from your (Windows) C:\Program Files (x86)\Unity\Editor\Data\Mono\lib\mono\unity folder, copy the I18N*.dll files to your Assets folder. There should be 6. These files will prevent the IBM487 errors.

My methods for reading and writing to data files are:

/// <summary> /// Puts an item in the archive, overwrites if already exists /// </summary> /// <typeparam name="T"></typeparam> /// <param name="folder"></param> /// <param name="fileName"></param> /// <param name="item"></param> public void AddItemToArchive<T>(string folder, string fileName, ref T item) { if (!item.GetType().IsSerializable) throw new ArgumentException("item must be serializable");

     using (ZipFile zipFile = new ZipFile())
     {
         zipFile.UseUnicodeAsNecessary = true;

         //serialize item to memorystream
         using (MemoryStream m = new MemoryStream())
         {
             IFormatter formatter = new BinaryFormatter();
             formatter.Serialize(m, item);
             m.Position = 0;

             ZipEntry zipEntry = zipFile.AddEntry("entry", m);
             zipEntry.UseUnicodeAsNecessary = true;
             zipEntry.Password = _password;

             zipFile.Save(filePath);
         }
     }
 }

 /// <summary>
 /// Retrieves an item from the archive
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="folder"></param>
 /// <param name="fileName"></param>
 /// <returns></returns>
 public T GetItemFromArchive<T>(string folder, string fileName)
 {
     //get the stream from the archive
     using (MemoryStream m = new MemoryStream())
     {
         using (ZipFile zipFile = new ZipFile(filePath))
         {
             zipFile.UseUnicodeAsNecessary = true;

             ZipEntry e = zipFile["entry"];
             e.UseUnicodeAsNecessary = true;
             e.Password = _password;
             e.Extract(m);
             m.Position = 0;

             //now serialize it back to the correct type
             IFormatter formatter = new BinaryFormatter();
             T item = (T)formatter.Deserialize(m);

             return item;
         }
     }
 }

I hope this helps. ;o)

Have you tried looking at 7Zip? Has a completely managed C# library that I know works in Unity. It gives you compress/uncompress to and from memory streams/byte arrays, in LZMA format, so it's better than zip and actually what Unity uses to compress assets.

http://www.7-zip.org/sdk.html

If you need something compatible with .zip format you might have some trouble.

Thanks for this post, was very useful. I would like to add that on iOS webrequests are automatically uncompressed when setting the requestheader to "gzip", so on iOS is no need for an extra uncompression library.

Potential Answer: SharpZipLib

There has been no progress on this question so I will post my research into this potential answer.

http://www.icsharpcode.net/opensource/sharpziplib/

The current version of SharpZipLib seems to work. Code will compile and run in the Unity editor. But the same problem with DotNetZip arises:

NotSupportedException: CodePage 437 not supported

is thrown when the project is built and running on the mono bits.

Another SharpZipLib/Unity developer banged his head on the wall last year and was able to get the code to work with the Unity version of the SharpZipLib library: http://community.sharpdevelop.net/forums/p/9762/27065.aspx

His bug demo code was still posted, so I grabbed the .dll from it and used it in my code. It WORKS! But, I won't immediately call this an acceptable answer to this question. This is the version of the library that ships with Unity (located here: Unity\Editor\Data\Frameworks\Mono.framework), so whatever bugfixes or improvements may have happened after this version was published, or may happen in the future, are lost to me.

This is the closest answer yet, but we're still not there yet. If others post their experiences with this solution, then I may feel better about calling this the answer.