Formát 7z je populární volbou pro kompresi s vysokým poměrem a distribuci. S Aspose.ZIP for .NET, můžete vytvářet soubory 7z programově pomocí jednoduchého a moderního API. Tento průvodce prochází funkční minimální příklad a přidává praktické vzory pro reálné projekty, jako je přidávání souborů z disku, přenos dat z paměti, kontrola vstupních názvů a složek uvnitř archivu a základní správa chyb.

Všechny ukázky kódu jsou inline a autonomní.

Požadavky přehled

  • .NET 6 nebo novější
  • balíček NuGet Aspose.Zip
dotnet add package Aspose.Zip

Jmenné prostory použité v příkladech: Aspose.Zip, Aspose.Zip.SevenZip

Chcete-li vytvořit soubor 7z s jedním souborem, postupujte podle těchto kroků:

Tento minimální příklad vytvoří nový soubor 7z v paměti, přidá dva záznamy a uloží jej na disk.

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

class Program
{
    static void Main()
    {
        var outputPath = "example.7z";

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

            // Add a file from disk
            var sourceFile = "report.pdf"; // ensure this file exists
            if (File.Exists(sourceFile))
            {
                using var fs = File.OpenRead(sourceFile);
                archive.CreateEntry("reports/2025/report.pdf", fs);
            }

            // Save the 7z archive
            using var outStream = File.Create(outputPath);
            archive.Save(outStream);
        }

        Console.WriteLine("Saved 7z: " + Path.GetFullPath(outputPath));
    }
}

Co je třeba poznamenat

  • SevenZipArchive začni prázdně, pak volání CreateEntry(entryName, stream) za článek.
  • Názvy vstupů definují strukturu složek v souboru, například docs/readme.txt.
  • Můžeš předat jakýkoli čitelný. Stream, což je užitečné pro data, která generujete v paměti.

Přidat celý kartonový strom

Procházejte adresář rekurzivně, zachovejte jeho relativní strukturu v souboru a uložte jako .7z.

using System;
using System.IO;
using Aspose.Zip.SevenZip;

static class FolderTo7z
{
    public static void CreateFromFolder(string sourceDir, string output7z)
    {
        if (!Directory.Exists(sourceDir))
            throw new DirectoryNotFoundException(sourceDir);

        using var archive = new SevenZipArchive();

        var basePath = Path.GetFullPath(sourceDir);
        foreach (var filePath in Directory.GetFiles(basePath, "*", SearchOption.AllDirectories))
        {
            var relPath = Path.GetRelativePath(basePath, filePath)
                              .Replace(Path.DirectorySeparatorChar, '/'); // normalize to forward slashes

            using var fs = File.OpenRead(filePath);
            archive.CreateEntry(relPath, fs);
        }

        using var outStream = File.Create(output7z);
        archive.Save(outStream);
    }
}

// Usage
// FolderTo7z.CreateFromFolder(@Path.Combine("C:", "data", "input"), "bundle.7z");

Typ

  • Použij Path.GetRelativePath pro udržení čistého vnitřního uspořádání složek.
  • Normalizovat oddělovače cest pro přesměrování ořezů pro konzistentní položky archivu.

Bezpečný přenos velkých souborů

Při přidávání velkých souborů je přenášejte jako stream místo uložení celého souboru do paměti. Předchozí základní vzor s File.OpenRead již přenášeno. Pokud generujete obsah podle libosti, zapište jej do. Stream a předej tento proud přímo do CreateEntry.

using System.IO;
using System.Text;
using Aspose.Zip.SevenZip;

static void AddGeneratedCsv(SevenZipArchive archive, string entryName)
{
    // Example generator that writes CSV rows in a forward-only fashion
    using var pipe = new MemoryStream();
    using var writer = new StreamWriter(pipe, Encoding.UTF8, leaveOpen: true);

    writer.WriteLine("id,name");
    for (int i = 1; i <= 1000; i++)
        writer.WriteLine($"{i},Item {i}");

    writer.Flush();
    pipe.Position = 0;

    archive.CreateEntry(entryName, pipe);
}

Organizovat vstupy s pomocníkem

Pro větší úkoly použijte malého pomocníka k přidání souborů se společnou předponou.

using System.IO;
using Aspose.Zip.SevenZip;

static class SevenZipHelpers
{
    public static void AddFile(SevenZipArchive archive, string rootPrefix, string fullPath)
    {
        var relName = Path.Combine(rootPrefix, Path.GetFileName(fullPath))
                           .Replace(Path.DirectorySeparatorChar, '/');
        using var fs = File.OpenRead(fullPath);
        archive.CreateEntry(relName, fs);
    }
}

Příklad od začátku do konce s registrací a základními kontrolami

Tento příklad vytváří soubor 7z z smíšeného seznamu zdrojů.

// File: BuildArchive.cs
using System;
using System.Collections.Generic;
using System.IO;
using Aspose.Zip.SevenZip;

public static class BuildArchive
{
    public static bool Run(IEnumerable<string> paths, string output7z)
    {
        if (paths == null) throw new ArgumentNullException(nameof(paths));
        Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(output7z)) ?? ".");

        int added = 0, skipped = 0;

        using var archive = new SevenZipArchive();

        foreach (var p in paths)
        {
            if (string.IsNullOrWhiteSpace(p)) { skipped++; continue; }

            if (File.Exists(p))
            {
                using var fs = File.OpenRead(p);
                var entryName = Path.GetFileName(p);
                archive.CreateEntry(entryName, fs);
                Console.WriteLine("Added file: " + entryName);
                added++;
            }
            else if (Directory.Exists(p))
            {
                var basePath = Path.GetFullPath(p);
                foreach (var fp in Directory.GetFiles(basePath, "*", SearchOption.AllDirectories))
                {
                    var rel = Path.GetRelativePath(basePath, fp).Replace(Path.DirectorySeparatorChar, '/');
                    using var fs = File.OpenRead(fp);
                    archive.CreateEntry(rel, fs);
                    Console.WriteLine("Added: " + rel);
                    added++;
                }
            }
            else
            {
                Console.WriteLine("Skip missing: " + p);
                skipped++;
            }
        }

        using var outStream = File.Create(output7z);
        archive.Save(outStream);

        Console.WriteLine($"Saved: {Path.GetFullPath(output7z)}");
        Console.WriteLine($"Entries added: {added}, skipped: {skipped}");
        return added > 0;
    }
}

// Usage sample:
// BuildArchive.Run(new [] { "README.md", "assets", "docs/spec.pdf" }, "release.7z");

Dobré praktiky

  • Používejte lomítka pro názvy vstupů Mnoho nástrojů zobrazuje cesty konzistentněji, když vstupy používají. / s oddělovačem.
  • Uvolnit toky Vždy zabalte souborové proudy do using bloky. Předchozí vzorky zajišťují čisté odstranění.
  • Ověřte vstupy Zkontrolujte, že soubory existují, než je přidáte. Poskytněte jasné záznamy pro vynechané cesty.
  • Udržujte strukturu souboru čistou Zvolte název kořenové složky v souboru a zachovejte jej, například app/ o package/.
  • Test na cílových platformách Ověřte, že se váš 7z správně otevírá v nástrojích, na které se vaši uživatelé spoléhají.

Životopis

Vytvořili jste soubor 7z programově pomocí Aspose.ZIP for .NET, byly přidány soubory z disku i z paměti, byla zachována čistá struktura složek a výsledek byl uložen do .7z. Používejte tyto vzory k balení verzí, balíčků a exportů přímo z vašich aplikací C#.

More in this category