If you're trying to generate ZIPs and send them to the browser using ASP.NET Core, check out "Create ZIP files on HTTP request without intermediate files using ASP.NET MVC, Razor Pages, and endpoints".
.NET has multiple built-in APIs to create ZIP files. The `ZipFile` class has static methods to create and extract ZIP files without dealing with streams and byte-arrays. `ZipFile` is a great API for simple use-cases where the source and target are both on disk.You can find all the source code on this GitHub Repository.
## Create a ZIP using streams and the ZipArchive class {#create-a-zip-using-streams-and-the-ziparchive-class} For this demo, I have downloaded all the .NET bots from [the .NET Brand repository](https://github.com/dotnet/brand) and put them in a folder:
var botFilePaths = Directory.GetFiles("/path/to/bots"); using (var zipFileMemoryStream = new MemoryStream()) { using (ZipArchive archive = new ZipArchive(zipFileMemoryStream, ZipArchiveMode.Update, leaveOpen: true)) { foreach (var botFilePath in botFilePaths) { var botFileName = Path.GetFileName(botFilePath); var entry = archive.CreateEntry(botFileName); using (var entryStream = entry.Open()) using (var fileStream = System.IO.File.OpenRead(botFilePath)) { await fileStream.CopyToAsync(entryStream); } } } zipFileMemoryStream.Seek(0, SeekOrigin.Begin); // use stream as needed }The code does the following: - Get all paths to the bot files in the folder using
Directory.GetFiles and store it in botFilePaths.
- You can use any stream which supports synchronous read and write operations, but for this snippet a MemoryStream is used which will store the entire ZIP file in memory. This can consume a lot of memory which is why a different stream will be used in later samples.MemoryStream and store it in zipFileMemoryStream. The ZIP archive will be written to zipfileMemoryStream.FileStream instead of a MemoryStream if you want to write the ZIP archive to a file on disk.
- Create a new ZipArchive and store it in archive. Instantiate the ZipArchive with the following parameters
- stream: pass in zipFileMemoryStream. The ZipArchive wraps the stream and uses it to read/write.
- mode: pass in ZipArchiveMode.Update to allow both reading and writing. Other options are Read and Create
- leaveOpen: pass in true to leave open the underlying stream after disposing the ZipArchive. Otherwise zipfileMemoryStream will be disposed when ZipArchive is disposed which prevents you from interacting with the stream.
- For every path in botFilePaths:
- Extract the file name from the bot file path and store it in botFileName.
- Create a ZipArchiveEntry by calling archive.CreateEntry passing in the file name. This entry is where the file data will be stored.
- Get a writable Stream to write to the ZipArchiveEntry by calling entry.Open().
- Open a readable FileStream to read the bot file by calling System.IO.File.OpenRead passing in the bot file path. System.IO.File and the File method inside of MVC controllers and Razor Pages.
- Copy the data from the file stream to the zip entry stream.
- If you now want to read from the memory stream, you have to set the position of the stream back to the beginning. You can do this using .Seek(0, SeekOrigin.Begin).
- Lastly, do whatever you need to do with your in-memory ZIP file.
Warning: Your mileage may vary depending on the size and amount of files you're trying to archive and the amount of resources available on your machine. Saving the ZIP file to disk may be favorable in some scenarios so you can save some rework when the same files are requested again.
If you eventually end up saving or downloading this ZIP archive to disk, it will look like this:
The solution below (first version) stores the entire ZIP file in memory (MemoryStream) before sending the entire file to the client. Feel free to skip to the next section to see the improved version.
using System; using System.IO; using System.IO.Compression; using System.Web.Mvc; namespace WebZipItFramework.Controllers { public class HomeController : Controller { public ActionResult Index() { return View(); } public ActionResult ZipUnoptimized() { var contentPath = Server.MapPath("~/bots/"); var files = Directory.GetFiles(contentPath); var zipFileMemoryStream = new MemoryStream(); using (ZipArchive archive = new ZipArchive(zipFileMemoryStream, ZipArchiveMode.Update, leaveOpen: true)) { foreach (var file in files) { var entry = archive.CreateEntry(Path.GetFileName(file)); using (var entryStream = entry.Open()) using (var fileStream = System.IO.File.OpenRead(file)) { fileStream.CopyTo(entryStream); } } } zipFileMemoryStream.Seek(0, SeekOrigin.Begin); return File(zipFileMemoryStream, "application/octet-stream", "Bots.zip"); } } }The majority of the code is the same as the prior sample, but there are a couple of changes to take note off: - The bot files have been stored in a folder in the ASP.NET project called "bots". To get the path to the folder, use the
Server.MapPath method.
- The zipFileMemoryStream is not in a using block anymore. That's because the stream will be returned to the invoker and disposed of later.
- The File method inherited from the Controller is invoked which returns a FileStreamResult. You could create the FileStreamResult yourself, but the File method is provided as a more convenient way to do it.File method uses the following signature with these parameters:
- fileStream: Pass in the stream holding the data you want to send to the client which in this case is zipFileMemoryStream.
- contentType: Provide the content-type of the file. Pass in "application/octet-stream" for binary files or any files you want to force the browser to download instead of display.
- fileDownloadName: Tells the browser which file name to use for the downloaded file.
- At the end of the ZipUnoptimized action, the FileStreamResult is returned to MVC and MVC will send the data to the client and dispose of the stream.
The associated view generates the link to the `ZipUnoptimized` action as follows:
<div class="text-center"> <a class="btn btn-primary" href="@Url.Action("ZipUnoptimized")"> Download .NET Bots unoptimized </a> </div>
To give this a try, download the sample repository and run it locally. Then, open the browser and browse to 'https://localhost:44334'.
On this page, click on the "Download .NET Bots unoptimized" which will execute the code above, and download the .NET Bots ZIP file.
using System; using System.IO; using System.IO.Compression; using System.Web.Mvc; namespace WebZipItFramework.Controllers { public class HomeController : Controller { // omitted existing code for brevity public void ZipOptimized() { Response.ContentType = "application/octet-stream"; Response.Headers.Add("Content-Disposition", "attachment; filename=\"Bots.zip\""); Response.BufferOutput = false; var contentPath = Server.MapPath("~/bots/"); var files = Directory.GetFiles(contentPath); using (ZipArchive archive = new ZipArchive(new PositionWrapperStream(Response.OutputStream), ZipArchiveMode.Create)) { foreach (var file in files) { var entry = archive.CreateEntry(Path.GetFileName(file)); using (var entryStream = entry.Open()) using (var fileStream = System.IO.File.OpenRead(file)) { fileStream.CopyTo(entryStream); } } } } } // from https://stackoverflow.com/a/21513194/2919731 public class PositionWrapperStream : Stream { private readonly Stream wrapped; private long pos = 0; public PositionWrapperStream(Stream wrapped) { this.wrapped = wrapped; } public override bool CanSeek { get { return false; } } public override bool CanWrite { get { return true; } } public override long Position { get { return pos; } set { throw new NotSupportedException(); } } public override void Write(byte[] buffer, int offset, int count) { pos += count; wrapped.Write(buffer, offset, count); } public override void Flush() { wrapped.Flush(); } protected override void Dispose(bool disposing) { wrapped.Dispose(); base.Dispose(disposing); } // all the other required methods can throw NotSupportedException public override bool CanRead => throw new NotImplementedException(); public override long Length => throw new NotImplementedException(); public override long Seek(long offset, SeekOrigin origin) { throw new NotImplementedException(); } public override void SetLength(long value) { throw new NotImplementedException(); } public override int Read(byte[] buffer, int offset, int count) { throw new NotImplementedException(); } } }There are some important differences compared to the previous solution to take note off: - There's no return type because the `File` method and `FileStreamResult` class is not being used anymore. Instead of using `File` and `FileStreamResult`, the data will be written to the body inside the action. - Instead of passing the filename and content-type to the `File` method, the headers are set directly on the `Response` object. - Instead of using `ZipArchiveMode.Update`, you need to use `ZipArchiveMode.Create`. - Instead of using `leaveOpen: true`, the parameter is omitted and the stream will be disposed of when the `ZipArchive` is disposed. - The `.Seek` and `File` method are no longer necessary. The associated view generates the link to the `ZipOptimized` action as follows:
<div class="text-center"> <a class="btn btn-primary" href="@Url.Action("ZipUnoptimized")"> Download .NET Bots unoptimized </a> <a class="btn btn-primary" href="@Url.Action("ZipOptimized")"> Download .NET Bots optimized </a> </div>
To give this a try, download the sample repository and run it locally. Then, open the browser and browse to 'https://localhost:44334'.
On this page, click on the "Download .NET Bots optimized" which will execute the code above, and download the .NET Bots ZIP file.