Das Erstellen eines ZIP im Speicher ist nützlich, wenn Sie eine Download streamen müssen, Byte an einen anderen Service übertragen oder ein Archiv in einer Datenbank speichern, ohne auf den Disk zu berühren. Aspose.ZIP für .NET enthält eine saubere API, um Zip-Archive mit Streams zu erstellen, Komprimierungs-Einstellungen auswählen und das Ergebnis auf eine MemoryStream oder direkt zur HTTP-Reaktion.

Dieser Leitfaden bietet den vollständigen, korrekten Code, den Sie in eine Konsole-App oder ASP.NET Core-Projekt einfügen können.

Voraussetzung

  • .NET 6 oder später
  • Neugier : Aspose.Zip
dotnet add package Aspose.Zip

Namespaces verwendet werden:

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

Schneller Start: Erstellen Sie einen ZIP vollständig im Speicher

Dieses Beispiel fügt Beiträge aus einem String und eine Datei auf dem Disk hinzu, speichert das Archiv auf eine MemoryStream, und zeigt die resultierende 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");
    }
}
  • Schlüsselpunkte *
  • new Archive() Erstellt einen leeren ZIP.
  • CreateEntry(entryName, stream, entrySettings) Hinzufügen Sie eine Datei aus all readable stream.
  • archive.Save(stream) Schreiben Sie das Archiv zu Ihrem gewählten Stream (Memory, Network, Response Body).

Hinzufügen Sie ein volles Folderbaum ohne Temp-Dateien zu schreiben

Spazieren Sie ein Katalog wiederum, bewahren Sie relative Wege und schreiben Sie das letzte Archiv in das Gedächtnis.

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: Streaming eine ZIP-Download ohne Disk I/O

Dieses Endpoint baut ein ZIP in der Speicher aus mehreren Quellen auf und gibt es mit dem richtigen Inhaltstyp und einem Download-Filenname zurück.

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

*Warum geht es hier? *Minimale APIs erfordern eine konkrete Zahlungsbelastung. Für sehr große Dateien bevorzugen Sie Streaming direkt auf 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);
});

Wählen Sie Kompressionsinstellungen

DeflateCompressionSettings Geschwindigkeit vs Größe:

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 die Einstellungen über new ArchiveEntrySettings(deflate) bei der Erstellung von Eingängen. Sie können Einstellungen pro Eingang gemischt, wenn nötig.

Einträge von Streams sicher hinzufügen

  • Use File.OpenRead(path) um große Dateien zu streamen, ohne sie vollständig in das Speicher zu laden.
  • Für generierte Inhalte schreiben Sie zu einem MemoryStream oder A PipeWriter- unterstützt Stream und übertragen es zu CreateEntry.
  • Streams nach jedem CreateEntry Sofort freie Ressourcen.

Beispiele für große generierte Inhalte:

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

Validierung und Fehlerbehandlung

  • Check Inputs existieren, bevor Sie in das Archiv hinzufügen.
  • Die Schöpfung in try/catch und eine klare HTTP-Fehler für Web APIs zurückgeben.
  • Normalisieren Sie die Eintrittswege mit vorangegangenen Schlachten (/für ein konsequentes Verhalten über alle Instrumente.

Leistungskontrolle

  • Choose CompressionLevel.Low für real-time Downloads, wenn die Geschwindigkeit mehr als die Größe betrifft.
  • Vermeiden Sie die Ladung massiver Einträge vollständig in RAM; Stream von Dateien oder Netzwerkströmen.
  • Für sehr große Multi-GB-Archive, streamen Sie direkt auf HttpResponse.Body oder ein anderes Zielstrom statt Buffering.
  • Dispose Archive Und alle Einträge fließen deterministisch.

FAQ

** Kann ich den in-memory ZIP mit Passwort schützen?**Aspose.ZIP unterstützt verschlüsselte ZIP-Dateien. TraditionalEncryptionSettings oder AesEncryptionSettings durch ArchiveEntrySettingsAnmelde per Eingang beim Anrufen CreateEntry.

** Kann ich einen vorhandenen ZIP aktualisieren, den ich in die Speicher geladen habe?**Ja. Laden Sie es in eine Archive, hinzufügen oder entfernen Sie Beiträge, dann Save Zurück zu einem Stream.

** Funktioniert dies im Azure App Service oder in Container?**Ja. In-Memory und Streamed Zipping funktioniert gut in Sandboxed Umgebungen, wo Diskzugang begrenzt ist.

Zusammenfassung

Sie haben ein ZIP-Archiv ** vollständig im Speicher** mit Aspose.ZIP für .NET erstellt, Beiträge aus Strömen hinzugefügt, Kompression angepasst und das Archiv aus einem ASP.NET Core Endpunkt ohne vorübergehende Dateien zurückgegeben.

More in this category