Mit Aspose.ZIP für .NET können Sie 7z-Archive programmatisch mit einer einfachen, modernen API erstellen.Dieser Leitfaden führt durch ein minimales Arbeits Beispiel und fügt praktische Muster für reale Projekte hinzu, wie z. B. Datei aus dem Disk hinzufügen, Daten aus der Speicher streamen, Eingangsnamen und Ordner innerhalb des Archives kontrollieren und Grundfehlerbehandlung.

Alle Proben von Code sind inline und selbständig enthalten.

Voraussetzung

  • .NET 6 oder später
  • NuGet Paket Aspose.Zip
dotnet add package Aspose.Zip

Namenräume, die in den Proben verwendet werden:Aspose.Zip, Aspose.Zip.SevenZip

Schneller Start: Erstellen Sie ein 7z-Archiv mit einigen Dateien

Dieses minimale Beispiel erstellt ein neues 7z-Archiv im Speicher, fügt zwei Einträge hinzu und speichert es auf den 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));
    }
}
  • Was zu beachten*
  • SevenZipArchive beginnt leer, dann rufen Sie CreateEntry(entryName, stream) nach dem Punkt.
  • Eintrittsnamen definieren die Folderstruktur innerhalb des Archivs, wie docs/readme.txt.
  • Sie können jede Lesbarkeit übertragen Stream, die nützlich ist für die Daten, die Sie im Gedächtnis generieren.

Hinzufügen eines ganzen Folderbaums

Walk a directory recursively, bewahren Sie seine relative Struktur innerhalb des Archivs und speichern Sie als .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");
  • Tipp*
  • Use Path.GetRelativePath Um den internen Ordner-Layout sauber zu halten.
  • Normalisieren Sie die Path Separatoren, um Schläge für konsistente Archiv-Einträge voranzutreiben.

Große Dateien sicher streamen

Wenn Sie große Dateien hinzufügen, streamen Sie sie anstatt die gesamte Datei im Speicher zu buffern. File.OpenRead bereits streams. wenn Sie Inhalte auf dem fly generieren, schreiben Sie es an eine Stream und übertragen diesen Strom direkt zu 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);
}

Einträge mit einem Helfer organisieren

Für größere Jobs verwenden Sie einen kleinen Helfer, um Dateien mit einem gemeinsamen Vorschrift hinzuzufügen.

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

End-to-end Beispiel mit Logging und Grundprüfungen

Dieses Beispiel erstellt ein 7z-Archiv aus einer gemischten Liste von Quellen. Es validiert Paths und Logs Ergebnisse.

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

Beste Praktiken

  • Use vorausslashes für EingangsnamenViele Tools zeigen die Wege konsequenter, wenn Eingänge verwendet werden / Wie der Separator.

    • Streams verfügbar*Immer Dateienströme in using Blöcke. die oben genannten Proben gewährleisten saubere Entsorgung.
    • Validierte Einträge*Überprüfen Sie, welche Dateien vorhanden sind, bevor Sie sie hinzufügen. Bereitstellen Sie klare Logs für verschoben Paths.

  • Archivstruktur sauber haltenEntscheiden Sie sich über einen Wurzelfoldername innerhalb des Archivs und klicken Sie darauf, wie app/ oder package/.

  • Test auf ZielplattformenStellen Sie sicher, dass Ihre 7z richtig in den Werkzeugen öffnet, auf die sich Ihre Benutzer verlassen.

Zusammenfassung

Sie haben ein 7z-Archiv programmatisch mit Aspose.ZIP für .NET erstellt, Dateien aus Disk und Speicher hinzugefügt, eine saubere Ordnerstruktur beibehalten und das Ergebnis auf .7zVerwenden Sie diese Muster, um Verpackungen, Pakete und Exporte direkt aus Ihren C#-Anwendungen zu versenden.

More in this category