Compress Data on the Fly in C#

Overview

Aspose.ZIP for .NET lets you create archive entries from a stream provider. With overloads such as CreateEntry(string name, Func<Stream> streamProvider), you pass a delegate that returns the entry stream only when Aspose.ZIP is ready to consume it, instead of opening all source streams before archive composition starts.

This approach is especially useful when the source data comes from:

• HTTP responses
• cloud storage objects
• temporary files
• generated content that should exist only for a short time

With this pattern, you do not need to download each file beforehand or keep several network streams open while the archive is being prepared.

Why use a stream provider

The traditional CreateEntry(name, Stream) overload expects a stream that is already open. That works well for local files and memory streams, but it is less convenient for remote resources:

• all downloads must start before Save() begins
• several network streams may stay open longer than necessary
• some archive formats are stricter about the source stream capabilities

The stream-provider overload solves this by deferring the download until the entry is actually being compressed.

The sample URLs below use the reserved example.com domain. Replace them with your actual endpoints in a real application.

Safely dispose HTTP resources

When a stream provider returns response.Content.ReadAsStream(), the HttpResponseMessage must stay alive until Aspose.ZIP finishes reading that stream. The helper below binds the response lifetime to the returned stream, so disposing the stream also disposes the HTTP response.

using System;
using System.IO;
using System.Net.Http;

public sealed class ResponseOwnedStream : Stream
{
    private readonly HttpResponseMessage response;
    private readonly Stream inner;

    public ResponseOwnedStream(HttpResponseMessage response)
    {
        this.response = response ?? throw new ArgumentNullException(nameof(response));
        this.inner = response.Content.ReadAsStream();
    }

    public override bool CanRead => inner.CanRead;
    public override bool CanSeek => inner.CanSeek;
    public override bool CanWrite => inner.CanWrite;
    public override long Length
    {
        get
        {
            if (!inner.CanSeek)
                throw new NotSupportedException("The underlying HTTP stream does not support seeking.");

            return inner.Length;
        }
    }

    public override long Position
    {
        get
        {
            if (!inner.CanSeek)
                throw new NotSupportedException("The underlying HTTP stream does not support seeking.");

            return inner.Position;
        }
        set
        {
            if (!inner.CanSeek)
                throw new NotSupportedException("The underlying HTTP stream does not support seeking.");

            inner.Position = value;
        }
    }

    public override void Flush() => inner.Flush();
    public override int Read(byte[] buffer, int offset, int count) => inner.Read(buffer, offset, count);
    public override long Seek(long offset, SeekOrigin origin) => inner.Seek(offset, origin);
    public override void SetLength(long value) => inner.SetLength(value);
    public override void Write(byte[] buffer, int offset, int count) => inner.Write(buffer, offset, count);

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            inner.Dispose();
            response.Dispose();
        }

        base.Dispose(disposing);
    }
}

Compose ZIP archive from HTTP response

The following example downloads each file only when ZIP composition reaches that entry. CloseEntrySource = true makes Aspose.ZIP close each entry stream as soon as compression is complete, which in turn disposes the underlying HttpResponseMessage.

using System;
using System.IO;
using System.Net.Http;
using Aspose.Zip;
using Aspose.Zip.Saving;

string[] urls =
[
    "https://example.com/files/file1.txt",
    "https://example.com/files/file2.txt",
    "https://example.com/files/file3.txt"
];

using (HttpClient httpClient = new HttpClient())
using (FileStream zipFile = File.Open("result.zip", FileMode.Create))
using (Archive archive = new Archive())
{
    foreach (string url in urls)
    {
        Uri uri = new Uri(url);
        string entryName = Path.GetFileName(uri.AbsolutePath);

        archive.CreateEntry(entryName, () =>
        {
            using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
            HttpResponseMessage response = httpClient.Send(request, HttpCompletionOption.ResponseHeadersRead);
            response.EnsureSuccessStatusCode();
            return new ResponseOwnedStream(response);
        });
    }

    archive.Save(zipFile, new ArchiveSaveOptions() { CloseEntrySource = true });
}

Compose 7z archive from HTTP response

The same idea works for 7z archives. Here the stream provider is passed to SevenZipArchive.CreateEntry, and the save options close each downloaded stream right after the entry has been written to the archive.

using System;
using System.IO;
using System.Net.Http;
using Aspose.Zip.Saving;
using Aspose.Zip.SevenZip;

string[] urls =
[
    "https://example.com/files/file1.txt",
    "https://example.com/files/file2.txt",
    "https://example.com/files/file3.txt"
];

using (HttpClient httpClient = new HttpClient())
using (FileStream sevenZipFile = File.Open("result.7z", FileMode.Create))
using (SevenZipArchive archive = new SevenZipArchive())
{
    foreach (string url in urls)
    {
        Uri uri = new Uri(url);
        string entryName = Path.GetFileName(uri.AbsolutePath);

        archive.CreateEntry(entryName, () =>
        {
            using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
            HttpResponseMessage response = httpClient.Send(request, HttpCompletionOption.ResponseHeadersRead);
            response.EnsureSuccessStatusCode();
            return new ResponseOwnedStream(response);
        });
    }

    archive.Save(sevenZipFile, new SevenZipArchiveSaveOptions() { CloseEntrySource = true });
}

Compose CAB archive from HTTP response

This feature is particularly helpful for CAB composition. A plain HTTP response stream is usually non-seekable, so pre-opening remote streams is not always a practical approach. With a stream provider, the archive requests each stream only at the moment it needs that entry.

using System;
using System.IO;
using System.Net.Http;
using Aspose.Zip.Cab;

string[] urls =
[
    "https://example.com/files/file1.txt",
    "https://example.com/files/file2.txt",
    "https://example.com/files/file3.txt"
];

using (HttpClient httpClient = new HttpClient())
using (FileStream cabFile = File.Open("result.cab", FileMode.Create))
using (CabArchive archive = new CabArchive())
{
    foreach (string url in urls)
    {
        Uri uri = new Uri(url);
        string entryName = Path.GetFileName(uri.AbsolutePath);

        archive.CreateEntry(entryName, () =>
        {
            using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
            HttpResponseMessage response = httpClient.Send(request, HttpCompletionOption.ResponseHeadersRead);
            response.EnsureSuccessStatusCode();
            return new ResponseOwnedStream(response);
        });
    }

    archive.Save(cabFile, new CabSaveOptions() { CloseEntrySource = true });
}

Practical notes

• The provider delegate is called during archive saving, not during entry registration.
• The delegate should return a fresh readable stream for that entry.
• HttpCompletionOption.ResponseHeadersRead is useful for large downloads because it starts streaming the body immediately.
• If the stream originates from HttpResponseMessage, keep the response alive until the returned stream is closed.
• If download of an entry fails while the archive is being saved, the exception propagates from Save().
• For ZIP archives, if you need custom source-lifetime handling, you can also close args.Entry.DataSource manually in EventsBag.EntryCompressed.