La construcció de la memòria per a la memòria és útil quan cal transmetre descàrregues, transferir bytes a un altre servei o emmagatzemar arxius a la base de dades sense tocar el disc. Aspose.ZIP for .NET presenta API neta per crear arxius ZIP amb l’ajuda de fluxos, selecciona configuracions per a la comprensió i escriure el resultat en MemoryStream o directament a la resposta HTTP.

Aquesta guia proporciona el codi complet, correcte, que podeu posar en la aplicació per a la consola o el projecte ASP.NET Core.

Premis

  • .NET 6 o posterior
  • НУГЕТ : Aspose.Zip
dotnet add package Aspose.Zip

Nom utilitzat :

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

Inici: creació de la memòria en ZIP

Aquest exemple afegeix arxius de la sèrie i arxius a la discografia, escriure arxius a la MemoryStream,- L’eliminació de la bateria de sortida.

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

Punts clau

  • new Archive() Creació de zip en blanc.
  • CreateEntry(entryName, stream, entrySettings) Afegir el fitxer de Cada flux llegit.
  • archive.Save(stream) Enllaç a l’arxiu de les persones que us han escollit (pamet, rede, telo na odgovora).

Afegir a arbre en fitxers sense escriure arxius amb velocitat

Anar a la direcció, guardar els camins i escriure l’arxiu final a la memòria.

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

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

        var deflate = new DeflateCompressionSettings();
        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: descàrrega a ZIP sense I/O al disc

Aquest lloc crea un codi de memòria ZIP de diverses fonts i el retorna amb el tipus de contingut correcte i el nom del fitxer per descarregar.

using System;
using System.IO;
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();
    var settings = new ArchiveEntrySettings(deflate);

    using (var archive = new Archive())
    {
        var ms = new MemoryStream(Encoding.UTF8.GetBytes("id,name\n1,Alice\n2,Bob\n"));
        archive.CreateEntry("data/users.csv", ms, settings);

        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);
        ms.Dispose();
    }

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

await app.StartAsync();
await app.StopAsync();
Console.WriteLine("ASP.NET app validated.");

Per què ToArray() És aquí? Les API mínimes requereixen un pes útil concret. Per a molts arxius grans prefereixes fer un flux directe a 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);
});

Seleccioneu la configuració de compressió

DeflateCompressionSettings Control de velocitat en relació a la mida:

using Aspose.Zip.Saving;
var fastest = new DeflateCompressionSettings();      // fastest, larger files
var balanced = new DeflateCompressionSettings();  // default balance
var smallest = new DeflateCompressionSettings();    // slowest, smallest files

Adaptació a la configuració a través new ArchiveEntrySettings(deflate) Quan creeu registres, podeu barrejar la configuració per a cada enregistrament si és necessari.

Afegir a les gravacions des del flux de forma segura

  • Utilitza File.OpenRead(path) Per transferir arxius grans sense carregar-los completament a la memòria.
  • Per a la creació de continguts, escriviu a MemoryStream o a PipeWriter- El flux es manté i es transmet a CreateEntry.
  • Descarrega’t després de cada CreateEntry Recursos lliures ràpidament.

Exemple de contingut generat:

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());
    archive.CreateEntry(name, temp, settings);
}

Validació i tractament d’errors

  • Comproveu si existeixen les introducions abans d’afegir-les a l’arxiu.
  • Creació de la corda en try/catch i retorna un error HTTP clar per API web.
  • La línia de sortida de la línia de sortida (/- Per comportament coherent en els diferents instruments.

Verificació de l’execució

  • Escull el CompressionLevel.Low Per descarregar en temps real, quan la velocitat és més important que la mida.
  • Eviteu la càrrega de gravats massives completament a la RAM; flux de fitxers o fluxos de xarxa.
  • Per a molts arxius de grans dimensions de múltiples GB, descarregueu directament a HttpResponse.Body o un altre flux de destinació en comptes d’un tampó.
  • Ordenar Archive Tots els fluxos d’entrada es defineixen determinísticament.

FAQ

Puc protegir el meu compte amb una contrasenya ZIP? Aspose.ZIP supports encrypted ZIP archives. Use TraditionalEncryptionSettings o AesEncryptionSettings a través ArchiveEntrySettings.Sol·licitud d’entrada en el telèfon CreateEntry.

Puc actualitzar el ZIP existent que he carregat a la memòria? I, per tant, carregueu-ho en Archive,afegir o eliminar en els registres, després de Save Tornem al flux.

Funciona això en el servei d’aplicacions d’Azure o en contenidors? Sí, en la memòria i en el temps de la censura, funcionen bé en el migdia amb les caixes de sorra, on l’accés al disc és limitat.

Resum

Creació d’arxius ZIP Tot en memòria amb Aspose.ZIP for .NET, afegir documents de les cadenes, corregir la compressió i retornar arxius de ASP.NET Core és el Utilitza aquests models per generar descàrregues, embalatges i exportar de manera eficient a les teves aplicacions de C#.

More in this category