Le format 7z est un choix populaire pour la compression et la distribution à haute proportion. Avec Aspose.ZIP pour .NET, vous pouvez créer des archives 7Z de manière programmée en utilisant une API simple et moderne. Ce guide passe par un exemple de travail minimal et ajoute des modèles pratiques pour les projets réels, tels que l’ajout de fichiers depuis le disque, les données en streaming depuis la mémoire, le contrôle des noms d’entrée et des dossiers à l’intérieur du fichier, et le traitement d’erreur de base.

Tous les échantillons de code sont en ligne et auto-contenus.

Principaux

  • .NET 6 ou plus tard
  • Nouveau paquet Aspose.Zip
dotnet add package Aspose.Zip

Les noms utilisés dans les échantillons :Aspose.Zip, Aspose.Zip.SevenZip

Démarrage rapide: Créer un fichier 7z avec quelques fichiers

Cet exemple minimal crée un nouvel archive 7z dans la mémoire, ajoute deux entrées et le sauvegarde au disque.

// 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’est-ce qu’il faut remarquer*
  • SevenZipArchive commence vide, puis vous appelez CreateEntry(entryName, stream) par élément.
  • Les noms d’entrée définissent la structure des dossiers à l’intérieur du fichier, tels que docs/readme.txt.
  • Vous pouvez passer n’importe quelle lecture Stream, qui est utile pour les données que vous générez dans la mémoire.

Ajoutez un arbre entier

Walk a directory recursivement, préserve sa structure relative à l’intérieur de l’archive, et sauvegarde comme .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");
  • Les conseils *
  • Utiliser Path.GetRelativePath Pour maintenir le layout intérieur de la dossier propre.
  • Normalisez les séparateurs de route pour avancer les déchets pour les entrées d’archive cohérentes.

Transférer de grands fichiers en toute sécurité

Lorsque vous ajoutez de grands fichiers, les fluxez plutôt que de buffer l’ensemble du fichier dans la mémoire. File.OpenRead Si vous générez du contenu sur le vol, écrivez-le à un Stream et passez ce flux directement à 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);
}

Organiser des entrées avec un assistant

Pour des tâches plus grandes, utilisez un petit assistant pour ajouter des fichiers avec un préfix commun. Cela maintient votre structure d’archive prévisible.

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 fin à fin avec le logging et les contrôles de base

Cet exemple crée un archive 7z à partir d’une liste mixte de sources. Il valide les voies et les résultats des journaux.

// 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 meilleures pratiques

  • Utiliser les slashes à l’avant pour les noms d’entréeDe nombreux outils affichent les voies de manière plus cohérente lorsque les entrées sont utilisées / comme le séparateur.

    • Disposez de flux*Toujours intégrer les fichiers en using Les échantillons ci-dessus assurent une détachement propre.
    • Les entrées valides*Vérifiez que les fichiers existent avant de les ajouter. Fournir des journaux clairs pour les voies échappées.
    • Garder la structure de l’archive propre*Choisissez un nom de dossier de racine à l’intérieur de l’archive et appuyez sur celui-ci, comme app/ ou package/.

  • Test sur les plateformes cibléesVérifiez que votre 7z s’ouvre correctement dans les outils sur lesquels vos utilisateurs dépendent.

Résumé

Vous avez créé un fichier 7z de manière programmatique avec Aspose.ZIP pour .NET, ajouté des fichiers du disque et de la mémoire, conservé une structure de dossier propre, et sauvé le résultat à .7zUtilisez ces modèles pour les éditions d’emballage, les paquets et les exportations directement de vos applications C#.

More in this category