Formatul 7z este o alegere populară pentru compresie și distribuție de înaltă rată. cu Aspose.ZIP pentru .NET, puteți crea arhive 7Z în mod programat folosind o API simplă și modernă. Acest ghid trece printr-un exemplu de lucru minim și adaugă modele practice pentru proiecte reale, cum ar fi adăugarea fișierelor din disc, streamingul datelor din memorie, controlul numelor de intrare și a dosarelor în interiorul arhivului și gestionarea erorilor de baza.

Toate eșantionele de cod sunt inline și auto-conținute.

Prevederile

  • .NET 6 sau mai târziu
  • Pachetul nou Aspose.Zip
dotnet add package Aspose.Zip

Spatiile de nume utilizate in mostre:Aspose.Zip, Aspose.Zip.SevenZip

Start rapid: Creați un arhiv 7z cu câteva fișiere

Acest exemplu minim creează un nou arhiv 7z în memorie, adaugă două intrări și îl salvează pe disc.

// 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));
    }
}
  • Ce trebuie remarcat*
  • SevenZipArchive începe gol, apoi sunteți CreateEntry(entryName, stream) pe punctul respectiv.
  • Numele de intrare definește structura folderului din arhivă, cum ar fi: docs/readme.txt.
  • Puteți trece orice citit Stream, care este util pentru datele pe care le generați în memorie.

Adăugați un copac întreg

Urmăriți un director recursiv, păstrați structura sa relativă în interiorul arhivului și salvați ca .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(@"C:\data\input", "bundle.7z");

„Tipuri”

  • Utilizarea Path.GetRelativePath pentru a păstra layoutul folderului intern curat.
  • Normalizarea separatoarelor de cale pentru a depăși șocurile pentru intrările de arhivă consecvente.

Stream fișierele mari în siguranță

Atunci când adăugați fișiere mari, fluxându-le mai degrabă decât buffând întregul fișier în memorie. File.OpenRead Dacă generați conținut pe zbor, scrieți-l la un Stream și să treacă acest flux direct la 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);
}

Organizați intrări cu un ajutor

Pentru locuri de muncă mai mari, folosiți un ajutor mic pentru a adăuga fișiere cu un prefix comun.

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

Exemplu final-to-end cu logging și controale de bază

Acest exemplu creează un arhiv 7z dintr-o listă mixtă de surse. validă căile și rezultatele jurnalelor.

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

Cele mai bune practici

  • Utilizarea în avans a plăcilor pentru numele de intrareMulte instrumente afișează căi mai consecvent atunci când intrările sunt utilizate / Ca şi separatorul.

    • Dispunem de fluxuri*Întotdeauna păstrați fluxurile de fișiere în using Blocurile. eșantionele de mai sus asigură decontarea curată.
    • Introducere validată*Verificați că fișierele există înainte de a le adăuga. furnizați înregistrări clare pentru căile trecute.

  • Să păstrați structura arhivelor curatăDecideți despre un nume de folder de rădăcină în interiorul arhivului și păstrați-l, cum ar fi: app/ sau package/.

  • Testare pe platformele țintăAsigurați-vă că 7z se deschide corect în instrumentele pe care utilizatorii dvs. se bazează.

Rezumatul

Ați creat un arhiv 7z în mod programat cu Aspose.ZIP pentru .NET, ați adăugat fișiere de pe disc și memorie, s-a păstrat o structură de folder curată și rezultatul a fost salvat .7zUtilizați aceste modele pentru a colecta emisiuni, pachete și exporturi direct din aplicațiile dvs. C#.

More in this category