A memóriában lévő ZIP létrehozása hasznos, ha egy letöltést kell áthelyezni, bajtokat kell átadni egy másik szolgáltatásra, vagy archívumot kell tárolni egy adatbázisban érintés nélküli lemezben. Aspose.ZIP for .NET egy tiszta API-t mutat be, hogy áramlatokat használva létrehozzák a zIP archivumokat, válassza ki a tömörítési beállításokat és mentse az eredményt egy MemoryStream vagy közvetlenül a HTTP válaszhoz.

Ez az útmutató teljes, helyes kódot adhat be egy konzol alkalmazásba vagy az ASP.NET Core projektbe.

előfeltételek

  • .NET 6 vagy újabb
  • A NuGet: Aspose.Zip
dotnet add package Aspose.Zip

Használt nevek:

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

Gyors indítás: készítsen egy ZIP-t teljesen a memóriában

Ez a példa hozzáadja a bejegyzéseket egy sorból és egy fájlt a lemezre, mentse az archívumot a MemoryStream, és feltárja az eredményes byte array-t.

// 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");
    }
}
  • kulcsfontosságú pontok *
  • new Archive() Egy üres ZIP létrehozása.
  • CreateEntry(entryName, stream, entrySettings) Hozzáad egy fájlt a ** minden olvasható áramból**.
  • archive.Save(stream) írja az archívumot a kiválasztott áramhoz (memória, hálózat, válasz test).

Hozzáadjon egy egész mappát fájlokat írás nélkül

Folytassa a kézikönyv ismétlődő módon, megőrizze a relatív utakat, és írja be a végső archívumot a memóriába.

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: ZIP letöltés áramlása I/O lemez nélkül

Ez a végpont több forrásból egy ZIP-t épít a memóriában, és helyes tartalomtípusmal és letöltésű fájlnévvel visszaadja.

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

Miért van itt (vagy itt?)Minimális API-k konkrét fizetési terhelést igényelnek. nagyon nagy archívumok esetében előnyben részesíti a közvetlen streaminget 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);
});

Válassza ki a kompressziós beállításokat

DeflateCompressionSettings Gyorsaság vs méret:

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

Válassza ki a beállításokat a new ArchiveEntrySettings(deflate) beállítások létrehozásakor. szükség esetén keverheti beállításait.

Hozzáadjon bejegyzést az áramokból biztonságosan

  • Használat File.OpenRead(path) nagy fájlok áramlása anélkül, hogy teljesen feltöltené őket a memóriába.
  • A létrehozott tartalom, írjon a MemoryStream vagy a PipeWriter- támogatja az áramot, és átadja azt a CreateEntry.
  • Áramlást biztosít minden egyes CreateEntry Ingyenes erőforrások gyorsan.

Példa a nagy generált tartalmakra:

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

Validálás és hibaelhárítás

  • Ellenőrizze, hogy a bejegyzések léteznek, mielőtt hozzáadják az archívumhoz.
  • A teremtés beépítése try/catch és egyértelmű HTTP hiba helyreállítása a web API-k számára.
  • A bejárati útvonal normalizálása előrehaladásokkal (/a következetes viselkedés az eszközökön keresztül.

teljesítményellenőrzés

  • Choose CompressionLevel.Low valós idejű letöltések esetén, amikor a sebesség nagyobb, mint a méret.
  • Kerülje a tömeges bejegyzések feltöltése teljes mértékben a RAM-be; a fájlok vagy a hálózati áramlások árfolyama.
  • Nagyon nagy több GB-os archívumok, közvetlenül a HttpResponse.Body vagy egy másik cél áramlás helyett buffering.
  • Dispose Archive És minden belépési áramlást determinisztikusan.

FAQ

**A jelszóval védhetem a memóriában lévő ZIP-t?**Az Aspose.ZIP támogatja a titkosított ZIP archívumokat. TraditionalEncryptionSettings vagy AesEncryptionSettings keresztül ArchiveEntrySettingsJelentkezés a felhívás időpontjában CreateEntry.

**Meg tudok frissíteni egy meglévő ZIP-t, amelyet a memóriába töltöttem?**Igen, töltsd be egy Archivehozzáadni vagy eltávolítani a bejegyzéseket, majd Save Vissza az áramláshoz.

**Ez az Azure App Service-ben vagy tartályokban működik?**Igen. A memóriában és az áramlási zipping jól működik homokos környezetben, ahol a lemez-hozzáférés korlátozott.

Összefoglaló

Készített egy ZIP archívumot teljesen a memóriában a .NET-hez Aspose.ZIP-vel, hozzáadta az áramlásokból származó bejegyzéseket, beállította a tömörítést, és visszaküldte az archívet egy ASP.NET Core végpontból ideiglenes fájlok nélkül.

More in this category