Met Aspose.ZIP voor .NET kunt u 7z-archieven programmatisch maken met behulp van een eenvoudige, moderne API. Deze gids loopt door een minimaal werkende voorbeeld en voegt praktische patronen toe voor echte projecten, zoals het toevoegen van bestanden uit de schijf, het streamen van gegevens uit het geheugen, de controle van de ingangsnamen en mappen in het archief en de basale foutbehandeling.

Alle codeproeven zijn inline en zelfgehalte.

Voorwaarden

  • .NET 6 of later
  • NuGet pakket Aspose.Zip
dotnet add package Aspose.Zip

Namespaces gebruikt in de monsters:Aspose.Zip, Aspose.Zip.SevenZip

Snelle start: een 7z-archief maken met een paar bestanden

Dit minimaal voorbeeld creëert een nieuw 7z-archief in het geheugen, voegt twee inzichten toe en slaat het op de schijf.

// 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));
    }
}
  • Wat te merken *
  • SevenZipArchive begint leeg, dan bel je CreateEntry(entryName, stream) per item.
  • De entriesamen bepalen de mapstructuur binnen het archief, zoals: docs/readme.txt.
  • U kunt elke leesbare Stream, wat nuttig is voor de gegevens die u in het geheugen genereert.

Voeg een hele folderboom toe

Walk een directory recurrent, behoud zijn relatieve structuur binnen het archief, en bewaar 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");
  • tips *
  • Gebruik Path.GetRelativePath om de interne maplayout schoon te houden.
  • Normaliseren van de route-afscheiders om slagen voor consistente archiefinschrijvingen voort te zetten.

Grote bestanden veilig streamen

Bij het toevoegen van grote bestanden, streamen ze in plaats van de hele bestand in het geheugen. File.OpenRead al stromen.Als u inhoud op het vliegtuig genereert, schrijf het in een Stream en door die stroom rechtstreeks naar 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);
}

Organiseren van inschrijvingen met een assistent

Voor grotere werkzaamheden, gebruik een kleine helper om bestanden met een gemeenschappelijke voorschrift toe te voegen. dit houdt uw archiefstructuur voorspelbaar.

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 voorbeeld met logging en basischecks

Dit voorbeeld creëert een 7z archief uit een gemengde lijst met bronnen. het valideren paden en logs resultaten.

// 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 praktijken

  • ** Gebruik vooruit slashes voor ingangnamen**Veel gereedschappen tonen paden meer consistent wanneer input gebruikt / Zoals de scheiding.

    • Toegang tot stromen*Altijd bestandstromen in using blokken. de bovenstaande monsters zorgen voor schone ontbinding.
    • Valideerde inputs *Controleer dat de bestanden bestaan voordat u ze toevoegt. Geef duidelijke logs voor overgeschakelde paden.
    • Houd de archiefstructuur schoon*Besluiten over een wortel mapnaam in het archief en houd er bij, zoals: app/ of package/.

  • Test op doelplatformsZorg ervoor dat uw 7z correct opent in de tools waarop uw gebruikers vertrouwen.

Samenvatting

U hebt een 7z-archief programmatisch gecreëerd met Aspose.ZIP voor .NET, bestanden van de schijf en geheugen toegevoegd, een schone mapstructuur bewaard en het resultaat opgeslagen door .7zGebruik deze patronen om pakketverslagen, bundels en exports rechtstreeks uit uw C#-applicaties.

More in this category