Xây dựng một ZIP trong bộ nhớ là hữu ích khi bạn cần lưu một tải xuống, chuyển byte sang một dịch vụ khác, hoặc lưu trữ một tài liệu trong một cơ sở dữ liệu mà không cần chạm vào ổ đĩa. Aspose.ZIP cho .NET tiết lộ một API sạch để tạo các tập tin Zip bằng cách sử dụng dòng, chọn cài đặt nén, và lưu kết quả cho một MemoryStream hoặc trực tiếp với phản ứng HTTP.

Hướng dẫn này cung cấp mã đầy đủ và chính xác mà bạn có thể dán vào một ứng dụng console hoặc dự án ASP.NET Core.

Nguyên tắc

  • .NET 6 hoặc hơn
  • Nói : Aspose.Zip
dotnet add package Aspose.Zip

Tên không gian sử dụng:

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

Khởi động nhanh: Tạo một ZIP hoàn toàn trong bộ nhớ

Ví dụ này thêm các bài đăng từ một dòng và một tệp trên đĩa, lưu các tập tin vào một MemoryStream, và tiết lộ kết quả 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");
    }
}
  • Chìa khóa *
  • new Archive() Tạo một zip trống.
  • CreateEntry(entryName, stream, entrySettings) Thêm một tệp từ ** bất kỳ dòng có thể đọc**.
  • archive.Save(stream) viết lưu trữ cho dòng bạn đã chọn (ký ức, mạng lưới, cơ quan phản ứng).

Thêm một cây thư mục đầy đủ mà không viết tệp temp

Đi bộ một thư mục một cách lặp lại, bảo tồn các con đường tương đối, và viết lưu trữ cuối cùng vào ký ức.

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 một tải ZIP mà không có đĩa I/O

Điểm kết thúc này xây dựng một ZIP trong bộ nhớ từ nhiều nguồn và trả lại nó với loại nội dung chính xác và tên tệp tải xuống.

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

*Tại sao lại ở đây?*Các APIs tối thiểu đòi hỏi một khoản thanh toán cụ thể. Đối với các tập tin rất lớn, thích phát trực tiếp đến 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);
});

Chọn cài đặt Compression

DeflateCompressionSettings Kiểm soát tốc độ vs kích thước:

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

Đặt cài đặt qua new ArchiveEntrySettings(deflate) khi tạo entries. bạn có thể trộn các cài đặt cho mỗi entry nếu cần thiết.

Thêm nhập từ dòng chảy an toàn

  • Sử dụng File.OpenRead(path) để lưu các tập tin lớn mà không tải chúng hoàn toàn vào bộ nhớ.
  • Đối với nội dung được tạo ra, viết vào một MemoryStream hoặc a PipeWriter- Hỗ trợ dòng chảy và chuyển nó đến CreateEntry.
  • Có dòng chảy sau mỗi CreateEntry Tự do tài nguyên ngay lập tức

Ví dụ về nội dung được tạo ra lớn:

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

Chứng nhận và xử lý lỗi

  • Kiểm tra nhập tồn tại trước khi thêm vào lưu trữ.
  • Tạo sáng tạo trong try/catch và trả về một lỗi HTTP rõ ràng cho web APIs.
  • Bằng cách sử dụng các phương tiện giao thông đi bộ (/- Đối với hành vi liên tục trên các công cụ.

Danh sách kiểm tra hiệu suất

  • Choose CompressionLevel.Low cho tải về thời gian thực khi tốc độ quan trọng hơn kích thước.
  • Tránh tải các bản ghi lớn hoàn toàn vào RAM; dòng từ các tệp hoặc dòng mạng.
  • Đối với các tập tin đa GB rất lớn, lưu trữ trực tiếp đến HttpResponse.Body hoặc một dòng mục tiêu khác thay vì buffering.
  • Dispose Archive Và tất cả các input stream định nghĩa.

FAQ

** Tôi có thể bảo vệ mật khẩu trong bộ nhớ ZIP không?**Aspose.ZIP hỗ trợ các tập tin ZIP được mã hóa. TraditionalEncryptionSettings hoặc AesEncryptionSettings qua ArchiveEntrySettingsĐăng nhập khi gọi điện thoại CreateEntry.

** Tôi có thể cập nhật một ZIP hiện có mà tôi tải vào bộ nhớ không?**Đặt nó vào một Archive, thêm hoặc xóa các bài đăng, sau đó Save Trở lại dòng chảy.

** Điều này làm việc trong Azure App Service hoặc containers?**Vâng. in-memory và streamed zipping hoạt động tốt trong môi trường sandboxed nơi truy cập đĩa hạn chế.

Tổng hợp

Bạn đã tạo một lưu trữ ZIP tất cả trong bộ nhớ với Aspose.ZIP cho .NET, thêm các bài đăng từ các dòng, điều chỉnh nén, và trả về tài liệu từ một điểm kết thúc ASP.NET Core mà không có tệp tạm thời.

More in this category