Det 7z-formatet är ett populärt val för högkompression och distribution. Med Aspose.ZIP för .NET kan du skapa 7-Z-arkiv programmässigt med hjälp av en enkel, modern API. Denna guide går igenom ett minimalt arbetsexempel och lägger till praktiska mönster för verkliga projekt, såsom att lägga till filer från skivan, strömma data från minnet, kontrollera inmatningsnamn och mappar inom arkivet, och grundläggande felhantering.

Alla kodprover är inline och självinnehållna.

förutsättningar

  • .NET 6 eller senare
  • NuGet förpackning Aspose.Zip
dotnet add package Aspose.Zip

Namnutrymmen som används i proverna:Aspose.Zip, Aspose.Zip.SevenZip

Snabb start: Skapa ett 7z-arkiv med några filer

Detta minimala exempel skapar ett nytt 7z-arkiv i minnet, lägger till två ingångar och sparar det på en 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));
    }
}

*Vad man ska märka *

  • SevenZipArchive börjar tomt, då ringer du CreateEntry(entryName, stream) genom objektet.
  • Innehållsnamn definierar mappstrukturen inom arkivet, såsom docs/readme.txt.
  • Du kan gå igenom alla läsbara Stream, vilket är användbart för data som du genererar i minnet.

Lägg till ett helt mapparträd

Walk a directory recursively, bevara sin relativa struktur inuti arkivet, och spara som .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 *
  • Användning Path.GetRelativePath för att hålla den interna mapplayouten ren.
  • Normalisera spår separatorer för att föra slashes för konsekventa arkiv inmatningar.

Stream stora filer säkert

När du lägger till stora filer, strömma dem istället för att buffera hela filen i minnet. File.OpenRead redan strömmar. om du genererar innehåll på flyget, skriv det till en Stream och passera den strömmen direkt till 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);
}

Organisera entréer med en hjälpare

För större jobb, använd en liten hjälpare för att lägga till filer med en vanlig prefix. Detta håller din arkivstruktur förutsägbar.

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 exempel med logging och grundläggande kontroller

Detta exempel skapar ett 7z-arkiv från en blandad lista med källor. Det validerar vägar och loggar resultat.

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

Bästa praxis

  • Använd framåt slashes för entrénamnMånga verktyg visar vägar mer konsekvent när entréer används / som separatorn.

    • Tillhandahålla strömmar*Alltid infoga filströmmar i using block. de ovanstående proverna säkerställer ren avlägsnande.
    • Validerade inmatningar *Kontrollera att filer existerar innan du lägger till dem. Ge tydliga loggar för skidvägar.

  • Håll arkivstrukturen renBesluta om ett root-mappnamn inne i arkivet och klicka på det, till exempel app/ eller package/.

  • Test på målplattformarKontrollera att din 7z öppnas korrekt i de verktyg som dina användare förlitar sig på.

Sammanfattning

Du skapade ett 7z-arkiv programmässigt med Aspose.ZIP för .NET, lagt till filer från disk och minne, bevarade en ren mappstruktur och sparat resultatet till .7zAnvänd dessa mönster för att packa utlänningar, paket och export direkt från dina C#-applikationer.

More in this category