Het bouwen van een ZIP in het geheugen is nuttig wanneer u een download moet streamen, byten naar een andere service moet overbrengen of een archief in een database zonder aan te raken schijf moet opslaan. Aspose.ZIP voor .NET blootstelt een schone API voor het maken van zIP-archieven met behulp van stromen, selecteert compressie-instellingen en slaat het resultaat op een MemoryStream Of direct naar de HTTP reactie.

Deze gids biedt volledige, correcte code die u kunt plaatsen in een console app of ASP.NET Core project.

Voorwaarden

  • .NET 6 of later
  • NuGet : Aspose.Zip
dotnet add package Aspose.Zip

Namespaces gebruikt:

using Aspose.Zip;                 // Archive, ArchiveEntry
using Aspose.Zip.Saving;          // DeflateCompressionSettings, CompressionLevel

Snelle start: een ZIP volledig in het geheugen maken

Dit voorbeeld voegt inzichten uit een string en een bestand op de schijf toe, slaat het archief op een MemoryStream, en blootstelt de resulterende byte array.

// File: Program.cs
using System;
using System.IO;
using System.Text;
using Aspose.Zip;
using Aspose.Zip.Saving;

class Program
{
    static void Main()
    {
        // Prepare output buffer
        using var zipBuffer = new MemoryStream();

        // Choose compression (Deflate is the standard ZIP method)
        var deflate = new DeflateCompressionSettings(CompressionLevel.Normal);
        var entrySettings = new ArchiveEntrySettings(deflate);

        using (var archive = new Archive())
        {
            // 1) Add a text file from memory
            using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("Hello from Aspose.ZIP in memory.")))
            {
                archive.CreateEntry("docs/readme.txt", ms, entrySettings);
            }

            // 2) Add a file from disk (streamed; not fully loaded in RAM)
            var sourcePath = "report.pdf"; // ensure it exists
            if (File.Exists(sourcePath))
            {
                using var fs = File.OpenRead(sourcePath);
                archive.CreateEntry("reports/2025/report.pdf", fs, entrySettings);
            }

            // 3) Save the ZIP to our in-memory buffer
            archive.Save(zipBuffer);
        }

        // Use the ZIP bytes as needed (send over network, write to DB, etc.)
        byte[] zipBytes = zipBuffer.ToArray();
        Console.WriteLine($"ZIP size: {zipBytes.Length} bytes");
    }
}
  • sleutelpunten *
  • new Archive() Het creëert een lege zip.
  • CreateEntry(entryName, stream, entrySettings) voegt een bestand toe van ** elke leesbare stroom**.
  • archive.Save(stream) schrijft het archief naar uw gekozen stroom (memorie, netwerk, respons body).

Voeg een hele mapboom toe zonder temp-bestanden te schrijven

Walk een directory recursief, behoud relatieve paden, en schrijf het laatste archief in het geheugen.

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

static class InMemoryZipper
{
    public static byte[] ZipFolderToBytes(string sourceFolder, CompressionLevel level = CompressionLevel.Normal)
    {
        if (!Directory.Exists(sourceFolder))
            throw new DirectoryNotFoundException(sourceFolder);

        var deflate = new DeflateCompressionSettings(level);
        var entrySettings = new ArchiveEntrySettings(deflate);

        using var buffer = new MemoryStream();
        using (var archive = new Archive())
        {
            var root = Path.GetFullPath(sourceFolder);
            foreach (var filePath in Directory.GetFiles(root, "*", SearchOption.AllDirectories))
            {
                var rel = Path.GetRelativePath(root, filePath).Replace(Path.DirectorySeparatorChar, '/');
                using var fs = File.OpenRead(filePath);
                archive.CreateEntry(rel, fs, entrySettings);
            }

            archive.Save(buffer);
        }
        return buffer.ToArray();
    }
}

ASP.NET Core: stream een ZIP download zonder I/O schijf

Dit eindpunt bouwt een ZIP in het geheugen uit meerdere bronnen en retourneert het met de juiste inhoudstype en een downloadbestand.

// File: Program.cs (minimal API)
using System.Text;
using Aspose.Zip;
using Aspose.Zip.Saving;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/download-zip", () =>
{
    using var buffer = new MemoryStream();
    var deflate = new DeflateCompressionSettings(CompressionLevel.Normal);
    var settings = new ArchiveEntrySettings(deflate);

    using (var archive = new Archive())
    {
        // Add dynamic content (for example, a CSV generated on the fly)
        using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("id,name\n1,Alice\n2,Bob\n")))
            archive.CreateEntry("data/users.csv", ms, settings);

        // Add a static file from disk if available
        var logo = "wwwroot/logo.png";
        if (File.Exists(logo))
        {
            using var fs = File.OpenRead(logo);
            archive.CreateEntry("assets/logo.png", fs, settings);
        }

        archive.Save(buffer);
    }

    buffer.Position = 0; // rewind for reading
    return Results.File(
        fileContents: buffer.ToArray(),
        contentType: "application/zip",
        fileDownloadName: $"bundle-{DateTime.UtcNow:yyyyMMdd-HHmmss}.zip");
});

app.Run();

**Waarom ToArray() hier?**Minimale API’s vereisen een concrete lading. Voor zeer grote archieven, liever direct streamen naar HttpResponse.Body:

app.MapGet("/stream-zip", async (HttpContext ctx) =>
{
    ctx.Response.ContentType = "application/zip";
    ctx.Response.Headers.ContentDisposition = $"attachment; filename=\"bundle.zip\"";

    var deflate = new DeflateCompressionSettings(CompressionLevel.Normal);
    var settings = new ArchiveEntrySettings(deflate);

    using var archive = new Archive();

    // Add entries...
    using var ms = new MemoryStream(Encoding.UTF8.GetBytes("hello"));
    archive.CreateEntry("hello.txt", ms, settings);

    // Stream directly to the client without buffering full ZIP in RAM
    await archive.SaveAsync(ctx.Response.Body);
});

Selecteer compressieinstellingen

DeflateCompressionSettings Controleert snelheid vs grootte:

var fastest = new DeflateCompressionSettings(CompressionLevel.Low);      // fastest, larger files
var balanced = new DeflateCompressionSettings(CompressionLevel.Normal);  // default balance
var smallest = new DeflateCompressionSettings(CompressionLevel.High);    // slowest, smallest files

Pass de instellingen via new ArchiveEntrySettings(deflate) bij het creëren van entries. u kunt de instellingen per entry, indien nodig, mengen.

Voeg inzichten uit stromen veilig toe

  • Gebruik File.OpenRead(path) om grote bestanden te streamen zonder ze volledig in het geheugen te laden.
  • Voor geïntroduceerde inhoud, schrijf naar een MemoryStream Of een PipeWriter- ondersteunde stroom en doorgeeft het naar CreateEntry.
  • Geef stromen na elk CreateEntry Vrijheid van middelen snel.

Een voorbeeld van grotere geproduceerde inhoud:

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

static void AddLargeGeneratedEntry(Archive archive, string name)
{
    // simulate a big stream produced incrementally
    using var temp = new FileStream(Path.GetTempFileName(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, 81920, FileOptions.DeleteOnClose);
    using var writer = new StreamWriter(temp);
    for (int i = 0; i < 200_000; i++) writer.WriteLine($"row-{i},value-{i}");
    writer.Flush();
    temp.Position = 0;

    var settings = new ArchiveEntrySettings(new DeflateCompressionSettings(CompressionLevel.Normal));
    archive.CreateEntry(name, temp, settings);
}

Validatie en foutbehandeling

  • Check inputs bestaan voordat u toevoegt aan het archief.
  • Wrap creatie in try/catch en een duidelijke HTTP-fout voor web-API’s terugbrengen.
  • De vooruitgang van de oppervlakte (/voor consistente gedrag in alle instrumenten.

Performance Checklijst

  • Choose CompressionLevel.Low Voor realtime downloads wanneer de snelheid belangrijker is dan de grootte.
  • Vermijd het opladen van massieve entries volledig in RAM; stroom uit bestanden of netwerkstromen.
  • Voor zeer grote multi-GB-bestanden, direct naar HttpResponse.Body of een ander doelstream in plaats van buffering.
  • Dispose Archive En alle input stromen deterministisch.

FAQ

** Kan ik het in-memory ZIP wachtwoord beschermen?**Aspose.ZIP ondersteunt versleutelde ZIP-bestanden. TraditionalEncryptionSettings of AesEncryptionSettings via ArchiveEntrySettingsAanmelden per ingang bij het bellen CreateEntry.

** Kan ik een bestaande ZIP updaten die ik in het geheugen heb geladen?**Ja, laat het opladen in een Archive, toevoegen of verwijderen van entries, dan Save Terug naar een stroom.

** werkt dit in Azure App Service of containers?**Ja. In-memory en streamed zipping werkt goed in zandboxed omgevingen waar de toegang tot de schijf beperkt is.

Samenvatting

U hebt een ZIP-archief gemaakt ** volledig in geheugen** met Aspose.ZIP voor .NET, ingangen van stromen toegevoegd, gecomprimeerd en het archief teruggekeerd vanuit een ASP.NET Core eindpunt zonder tijdelijke bestanden.

More in this category