7z-formatet er et populært valg til kompression med høj komprimeringsgrad og distribution. S Aspose.ZIP for .NET, puedes crear archivos 7z programáticamente usando una API simple y moderna. Esta guía presenta un ejemplo mínimo funcional y añade patrones prácticos a proyectos reales, como la incorporación de archivos desde el disco, la transferencia de datos desde la memoria, la verificación de nombres de entrada y carpetas dentro del archivo y la gestión básica de errores.

Todos los ejemplos de código están incrustados y son autónomos.

Resumen de requisitos

  • .NET 6 o posterior
  • paquete NuGet Aspose.Zip
dotnet add package Aspose.Zip

Espacio de nombres que se usa en ejemplos: Aspose.Zip, Aspose.Zip.SevenZip

Si desea crear un archivo 7z con un archivo, siga los pasos a continuación:

Este ejemplo mínimo crea un nuevo archivo 7z en memoria, agrega dos entradas y lo guarda en el disco.

// 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é debe señalarse?

  • SevenZipArchive Empieza vacío, luego llama. CreateEntry(entryName, stream) en el artículo.
  • Los nombres de entrada definen la estructura de carpetas en el archivo, por ejemplo docs/readme.txt.
  • Puedes entregar cualquier cosa que sea legible. Stream, lo cual es útil para los datos que generas en la memoria.

Añade todo el árbol de papel

Navegación recursiva del directorio, manteniendo su estructura relativa en el archivo y guardando como .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(@Path.Combine("C:", "data", "input"), "bundle.7z");

tipo

  • Uso Path.GetRelativePath para mantener una estructura interna de carpetas limpia.
  • Normalización de los separadores del sitio para recorte de redirección y entradas de archivo consistentes.

Transferencia segura de archivos grandes

Cuando añades archivos grandes, debes transmitirlos en lugar de cargar todo el archivo en la memoria. El patrón básico anterior con File.OpenRead ya se ha transferido. Si estás creando contenido por tu propia solicitud, escríbelo dentro. Stream y transfiera este flujo directamente 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);
}

Organiza la introducción con el asistente

Para proyectos más grandes, debe usar el pequeño asistente para agregar archivos con un prefijo común.

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

Ejemplo de principio a fin con registro y verificaciones básicas

Este ejemplo crea un archivo 7z a partir de un directorio de fuentes mixto.

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

Buenas prácticas

  • Utilice barras diagonales para los nombres de entrada Muchas herramientas muestran rutas de forma más coherente cuando se utiliza la entrada. / con un separador.
  • Libera flujos Siempre empaquete los flujos de archivos en using Bloque. Las pruebas anteriores garantizan una eliminación limpia.
  • Confirmación de inicio de sesión Compruebe si los archivos existen antes de agregarlos. Proporcione registros claros para las rutas faltantes.
  • Mantenga la estructura de los archivos limpia Seleccione el nombre de la carpeta raíz en el archivo y manténgalo, por ejemplo. app/ ο package/.
  • Prueba en plataformas objetivo Confirme que su 7z se abre correctamente en las herramientas en las que confían sus usuarios.

CV

Creaste un archivo 7z programáticamente usando Aspose.ZIP for .NET, se añadieron archivos desde disco y memoria, la estructura de carpetas limpia se mantuvo, y el resultado se guardó en .7z. Utilice estas plantillas para empaquetar versiones, paquetes y exportar directamente desde sus aplicaciones C#.

More in this category