Comprimir o descomprimir archivos usando C# - Compresión y descompresión de archivos

Qué es ZIP (Formato de archivo)

ZIP es un formato de archivo de tipo archivo comprimido que admite compresión de datos sin pérdida. Un archivo ZIP puede contener uno o más archivos o directorios que hayan sido comprimidos. Los archivos ZIP generalmente usan las extensiones .zip o .ZIP y el tipo MIME application/zip. ZIP se utiliza como formato base por muchos programas, a menudo bajo un nombre diferente. Al navegar por un sistema de archivos mediante una interfaz gráfica, los íconos que representan archivos ZIP suelen aparecer como un documento u otro objeto que muestra prominentemente una cremallera.

Hay varias formas de comprimir (zip) archivos , según el sistema operativo que utilice. Y casi a diario, debemos comprimir o descomprimir algunos archivos y enviarlos a un servidor de almacenamiento o plataforma de intercambio de archivos. Afortunadamente, podemos automatizar ese proceso usando la API Aspose.ZIP . Le permite comprimir y descomprimir archivos sin preocuparse por la estructura subyacente de los archivos. Este artículo muestra cómo trabajar con compresión de un solo archivo y de varios archivos.

El paquete Aspose.ZIP puede añadirse a su proyecto .NET mediante el siguiente comando NuGet:

PM> Install-Package Aspose.Zip

Cómo comprimir un solo archivo con C#

Primero necesitamos crear un objeto de la clase FileStream para el archivo ZIP de salida.
Cargar un solo archivo en el objeto FileStream .
Crear un objeto de la clase Archive .
Agregar el archivo al archivo usando el método Archive.CreateEntry ( “FileName”, FileStream).
Crear el archivo ZIP usando el método Archive.Save (FileStream).

        using (FileStream zipFile = File.Open(dataDir + "CompressSingleFile_out.zip", FileMode.Create))
        {
            //File to be added to archive
            using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
            {
                    using (var archive = new Archive(new ArchiveEntrySettings()))
                {
                    archive.CreateEntry("alice29.txt", source1);
                    archive.Save(zipFile);
                }
            }
        }

Comprimir varios archivos con C#

La diferencia entre comprimir un solo archivo y varios archivos es que debemos cargar más archivos en el FileStream y añadirlos todos al archivo ZIP usando el método Archive.CreateEntry("FileName", FileStream).

El siguiente fragmento de código muestra cómo añadir varios archivos al ZIP usando FileStream.

        // Create FileStream for output ZIP archive
        using (FileStream zipFile = File.Open("compressed_files.zip", FileMode.Create))
        {
	        // File to be added to archive
	        using (FileStream source1 = File.Open("alice29.txt", FileMode.Open, FileAccess.Read))
	            {
		            // File to be added to archive
		            using (FileStream source2 = File.Open("asyoulike.txt", FileMode.Open, FileAccess.Read))
		        {
			        using (var archive = new Archive())
			            {
				            // Add files to the archive
				            archive.CreateEntry("alice29.txt", source1);
				            archive.CreateEntry("asyoulik3.txt", source2);
				            // ZIP the files
				            archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII, ArchiveComment = "two files are compressed in this archive" });
		            	}
		        }
	        }
        }

Comprimir archivos usando la clase FileInfo

Los archivos también pueden cargarse usando la clase FileInfo y luego añadirse al archivo ZIP de la misma manera que antes.
La clase FileInfo proporciona propiedades y métodos de instancia para la creación, copia, eliminación, movimiento y apertura de archivos, y ayuda en la creación de objetos FileStream.

    using (FileStream zipFile = File.Open("compressed_files.zip", FileMode.Create))
    {
	    // Files to be added to archive
	    FileInfo fi1 = new FileInfo("alice29.txt");
	    FileInfo fi2 = new FileInfo("fields.c");
	    using (var archive = new Archive())
	        {
		        // Add files to the archive
		        archive.CreateEntry("alice29.txt", fi1);
		        archive.CreateEntry("fields.c", fi2);
		        // Create ZIP archive
		        archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
	        }
    }

Almacenar archivos en archivos sin compresión

    //Creates zip archive without compressing files
    using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Create))
    {
    FileInfo fi1 = new FileInfo(dataDir + "alice29.txt");
    FileInfo fi2 = new FileInfo(dataDir + "lcet10.txt");

    using (Archive archive = new Archive(new ArchiveEntrySettings(new StoreCompressionSettings())))
    {
        archive.CreateEntry("alice29.txt", fi1);
        archive.CreateEntry("lcet10.txt", fi2);
        archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
    }
    }

Cómo crear archivos ZIP con contraseña en C#

    using (var archive = new Archive(new ArchiveEntrySettings(encryptionSettings: new TraditionalEncryptionSettings("pass"))))
    {
    archive.CreateEntry("entry_name1.dat", "input_file1.dat");
    archive.CreateEntry("entry_name2.dat", "input_file2.dat");
    archive.Save("result_archive.zip");
    }

El parámetro encryptionSettings se usa para crear un archivo ZIP protegido con contraseña.

Cómo descomprimir archivos ZIP con contraseña en C#

    using (var archive = new Archive("input_archive.zip", new ArchiveLoadOptions{DecryptionPassword = "pass"}))
    {
    archive.ExtractToDirectory("\\outputDirectory");
    }

La propiedad DecryptionPassword de ArchiveLoadOptions se utiliza para abrir un archivo ZIP protegido con contraseña.
Para ver ejemplos completos y archivos de datos, visite https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

Uso de compresión LZMA dentro de un archivo ZIP

El algoritmo Lempel–Ziv–Markov chain (LZMA) es un algoritmo utilizado para realizar compresión de datos sin pérdida. LZMA emplea un algoritmo de compresión por diccionario; el flujo comprimido es una secuencia de bits. La compresión LZMA dentro del archivo ZIP permite que los contenedores ZIP contengan entradas comprimidas con LZMA. El siguiente ejemplo de código muestra la implementación de la compresión LZMA usando la API Aspose.ZIP .

using (FileStream zipFile = File.Open(dataDir + "LZMACompression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new LzmaCompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Uso de compresión BZip2 dentro de un archivo ZIP

bzip2 es un programa de compresión de archivos libre y de código abierto que utiliza el algoritmo Burrows–Wheeler. Solo comprime archivos individuales y no es un archivador de archivos. Fue desarrollado por Julian Seward y mantenido por Mark Wielaard y Micah Snyder. El siguiente fragmento de código muestra la implementación de la compresión BZip2 usando la API Aspose.ZIP .

using (FileStream zipFile = File.Open(dataDir + "Bzip2Compression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new Bzip2CompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Uso de compresión PPMd dentro de un archivo ZIP

Prediction by partial matching (PPM) es una técnica adaptativa de compresión estadística de datos basada en modelado de contexto y predicción. Los modelos PPM utilizan un conjunto de símbolos previos en el flujo de símbolos sin comprimir para predecir el siguiente símbolo en el flujo. Los algoritmos PPM también pueden usarse para agrupar datos en agrupaciones previstas en análisis de clústeres. El siguiente fragmento de código muestra la implementación de la compresión PPMd usando la API Aspose.ZIP .

using (FileStream zipFile = File.Open(dataDir + "PPMdCompression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new PPMdCompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Descomprimir archivo con un solo archivo

using (FileStream fs = File.OpenRead(dataDir + "CompressSingleFile_out.zip"))
{
    using (Archive archive = new Archive(fs))
    {
        int percentReady = 0;
        archive.Entries[0].ExtractionProgressed += (s, e) =>
        {
            int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
            if (percent > percentReady)
            {
                Console.WriteLine(string.Format("{0}% decompressed", percent));
                percentReady = percent;
            }
        };
        archive.Entries[0].Extract(dataDir + "alice_extracted_out.txt");
    }
}

Descomprimir archivo con varios archivos

using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Open))
{
    StringBuilder sb = new StringBuilder("Entries are: ");
    int percentReady = 0;
    using (Archive archive = new Archive(zipFile,
        new ArchiveLoadOptions()
        {
            EntryListed = (s, e) => { sb.AppendFormat("{0}, ", e.Entry.Name); },
            EntryExtractionProgressed = (s, e) =>
            {
                int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
                if (percent > percentReady)
                {
                    Console.WriteLine(string.Format("{0}% compressed", percent)); percentReady = percent;
                }
            }
        }))
    {
        Console.WriteLine(sb.ToString(0, sb.Length - 2));
        using (var extracted = File.Create(dataDir + "alice_extracted_out.txt"))
        {
            using (var decompressed = archive.Entries[0].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }
        percentReady = 0;
        archive.Entries[1].Extract(dataDir + "asyoulik_extracted_out.txt");
    }
}

Extraer archivo almacenado sin compresión

using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Open))
{
    using (Archive archive = new Archive(zipFile))
    {
        using (var extracted = File.Create(dataDir + "alice_extracted_store_out.txt"))
        {
            using (var decompressed = archive.Entries[0].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }

        using (var extracted = File.Create(dataDir + "asyoulik_extracted_store_out.txt"))
        {
            using (var decompressed = archive.Entries[1].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }
    }
}

Para ver ejemplos completos y archivos de datos, visite https://github.com/aspose-zip/Aspose.ZIP-for-.NET .