El format 7z és una opció popular per a la compressió i la distribució d’alta taxa. amb Aspose.ZIP per .NET, es poden crear arxius 7Z programàticament utilitzant una simple, moderna API. Aquest guia passa a través de un exemple de treball mínim i afegeix patrons pràctics per als projectes reals, com ara afegir fitxers des del disc, streaming de dades des de la memòria, controlar els noms de entrades i mapes dins de l’arxiu, i el maneig de errors bàsics.

Tots els mostres de codi són en línia i autòcontenuts.

Prerequisits

  • .NET 6 o més tard
  • El paquet de NuGet Aspose.Zip
dotnet add package Aspose.Zip

Nom espais utilitzats en les mostres:Aspose.Zip, Aspose.Zip.SevenZip

Inici ràpid: crear un arxiu 7z amb pocs fitxers

Aquest exemple mínim crea un nou arxiu 7z en la memòria, afegeix dues entrades i l’emmagatzema al 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));
    }
}
  • Què cal saber *
  • SevenZipArchive Comença el buit, llavors es crida CreateEntry(entryName, stream) per punt.
  • Els noms d’entrada defineixen la estructura de la carpeta dins de l’arxiu, com ara docs/readme.txt.
  • Pots passar qualsevol llegible Stream, que és útil per a les dades que genera en la memòria.

Afegir un full d’arbre

Walk a directory recursivament, conserva la seva estructura relativa dins de l’arxiu, i salva com .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");
  • Tipus *
  • Use Path.GetRelativePath Per mantenir el disseny de la carpeta interna neta.
  • Normalitza els separadors de ruta per avançar les runes per a entrades d’arxiu consistents.

Fluir grans arxius de forma segura

Quan afegeixes grans fitxers, els flueix en lloc de bufar tot el fitxer en la memòria. File.OpenRead Si vostè genera contingut en el vol, escriure’l a un Stream i passar aquest flux directament a 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);
}

Organitza entrades amb un ajudant

Per a llocs de treball més grans, utilitzeu un petit ajudant per afegir fitxers amb un prefix comú.

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

Exemple de fi a fi amb logging i controls bàsics

Aquest exemple crea un arxiu 7z d’una llista mixta de fonts. Valida els trajectes i logs resultats.

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

Les millors pràctiques

  • ** Utilització d’avantguarda per a noms de entrades**Moltes eines mostren els camins més consistents quan s’utilitzen les entrades / Com el separador.

    • Disposar de fluxos *Sempre emmagatzema els arxius en using blocs. les mostres de dalt asseguren un dispositiu net.
    • Validació de les entrades *Verifiqueu que els arxius existeixen abans d’afegir-los. proporcionar registres clars per a camins escapats.

  • Mantenir l’estructura d’arxiu netDecideix sobre un nom de la carpeta arrel dins de l’arxiu i s’hi adherirà, com ara app/ o package/.

  • Test a les plataformes de targetesAssegureu-vos que el vostre 7z s’obre correctament en les eines en què els usuaris es confien.

Resum

Ha creat un arxiu 7z programàticament amb Aspose.ZIP per a .NET, ha afegit fitxers del disc i la memòria, s’ha conservat una estructura de mapes neta, i ha salvat el resultat a .7zUtilitzeu aquests patrons per emetre publicacions, paquets i exportacions directament de les vostres aplicacions C#.

More in this category