logo
Helpful resources ▼
  Nuget   Pricing   Buy

Comprimir o descomprimir archivos en .NET

Descripción general

Este artículo le enseñará cómo comprimir archivos Zip mediante programación utilizando una variedad de métodos utilizando C# o la API .NET y código de muestra. Aprenderá cómo comprimir o comprimir uno o más archivos, así como también cómo comprimir archivos simultáneamente. También aprenderá a descomprimir o descomprimir archivos.

Comprimir o comprimir archivos en C# y descomprimir o descomprimir archivos en C#

La API Aspose.ZIP le permite comprimir y descomprimir archivos sin preocuparse por la estructura del archivo subyacente. Este artículo muestra cómo trabajar con compresión de archivos únicos y múltiples.

Comprimir archivos

Comprimir un solo archivo

Pasos: Comprimir un solo archivo en C#

  1. Cree una secuencia de archivos con el nombre deseado de su archivo zip de salida.
  2. Cree una secuencia de archivos del archivo de datos que se va a comprimir.
  3. Cree una instancia de la clase Archive y pásele la instancia de la clase ArchiveEntrySettings.
  4. Agregue el archivo de datos creado en el paso 2 usando el método Archive.CreateEntry.
  5. Comprima el archivo de datos usando el método Archive.Save y pásele la secuencia de archivos creada en el paso 1.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "CompressSingleFile_out.zip", FileMode.Create))
 3    {
 4        //File to be added to archive
 5        using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
 6        {
 7            using (var archive = new Archive(new ArchiveEntrySettings()))
 8            {
 9                archive.CreateEntry("alice29.txt", source1);
10                
11                archive.Save(zipFile);
12            }
13        }
14    }

Comprimir varios archivos

Pasos: Comprimir varios archivos en C#

  1. Cree una secuencia de archivos con el nombre deseado de su archivo zip de salida.
  2. Cree una secuencia de archivos del primer archivo de datos que se va a comprimir.
  3. Cree una secuencia de archivos del segundo archivo de datos que se va a comprimir.
  4. Cree una instancia de la clase Archivo.
  5. Agregue los archivos de datos creados en los pasos 2 y 3 usando el método Archive.CreateEntry.
  6. Cree una instancia de la clase ArchiveSaveOptions.
  7. Comprima los archivos de datos usando el método Archive.Save y pásele la secuencia de archivos creada en el paso 1 y la instancia de ArchiveSaveOptions creada en el paso anterior.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Create))
 3    {
 4        using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
 5        {
 6            using (FileStream source2 = File.Open(dataDir + "asyoulik.txt", FileMode.Open, FileAccess.Read))
 7            {
 8                using (var archive = new Archive())
 9                {
10                    archive.CreateEntry("alice29.txt", source1);
11                    archive.CreateEntry("asyoulik.txt", source2);
12                    archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII, ArchiveComment = "There are two poems from Canterbury corpus" });
13                }
14            }
15        }
16    }
17

Comprimir archivos por información de archivo

Pasos: Comprimir archivos por información de archivo en C#

  1. Abra una secuencia de archivos con FileMode.Create con el nombre deseado de su archivo zip de salida.
  2. Cree el objeto FileInfo de su primer archivo de datos que se comprimirá.
  3. Cree el objeto FileInfo de su segundo archivo de datos que se va a comprimir.
  4. Cree una instancia de la clase Archivo.
  5. Agregue los archivos de datos creados en los pasos 2 y 3 usando el método Archive.CreateEntry.
  6. Cree una instancia de la clase ArchiveSaveOptions.
  7. Comprima los archivos de datos usando el método Archive.Save y pásele el flujo de archivos creado en el paso 1 y la instancia de ArchiveSaveOptions creada en el paso anterior.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "CompressFilesByFileInfo_out.zip", FileMode.Create))
 3    {
 4        FileInfo fi1 = new FileInfo(dataDir + "alice29.txt");
 5        FileInfo fi2 = new FileInfo(dataDir + "fields.c");
 6
 7        using (var archive = new Archive())
 8        {
 9            archive.CreateEntry("alice29.txt", fi1);
10            archive.CreateEntry("fields.c", fi2);
11            archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
12        }
13    }
14

Almacenamiento de archivos en archivos sin compresión

Pasos: Almacenamiento Archivos a archivos sin compresión usando C#1. Abra una secuencia de archivos con FileMode.Create con el nombre deseado de su archivo zip de salida. 2. Cree objetos FileInfo para que sus archivos de datos se almacenen en un archivo. 3. Cree una instancia de la clase ArchiveEntrySettings y pásele la instancia de la clase StoreCompressionSettings. 4. Cree una instancia de la clase Archive y pásele la instancia de la clase ArchiveEntrySettings creada en el paso anterior. 5. Agregue los objetos FileInfo creados en el paso 2 usando el método Archive.CreateEntry. 6. Cree una instancia de ArchiveSaveOptions y establezca Codificación = Codificación.ASCII. 7. Comprima los archivos de datos usando el método Archive.Save y pásele la secuencia de archivos creada en el paso 1 y la instancia de ArchiveSaveOptions creada en el paso anterior.

 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    //Creates zip archive without compressing files
 3    using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Create))
 4    {
 5        FileInfo fi1 = new FileInfo(dataDir + "alice29.txt");
 6        FileInfo fi2 = new FileInfo(dataDir + "lcet10.txt");
 7
 8        using (Archive archive = new Archive(new ArchiveEntrySettings(new StoreCompressionSettings())))
 9        {
10            archive.CreateEntry("alice29.txt", fi1);
11            archive.CreateEntry("lcet10.txt", fi2);
12            archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
13        }
14
15    }
16

Usar paralelismo para comprimir archivos

Pasos: Uso del paralelismo para comprimir archivos usando C#

  1. Abra una secuencia de archivos con FileMode.Create con el nombre deseado de su archivo zip de salida.
  2. Abra secuencias de archivos con FileMode.Open y FileAccess.Read para comprimir el primer y segundo archivo de datos.
  3. Cree una instancia de la clase Archivo.
  4. Agregue los archivos de datos creados en el paso 2 usando el método Archive.CreateEntry.
  5. Cree una instancia de ParallelOptions y establezca ParallelCompressInMemory = ParallelCompressionMode.Always.
  6. Cree una instancia de ArchiveSaveOptions y establezca su propiedad ParallelOptions con la instancia anterior.
  7. Comprima los archivos de datos usando el método Archive.Save y pásele la secuencia de archivos creada en el paso 1 y la instancia de ArchiveSaveOptions creada en el paso anterior.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "UsingParallelismToCompressFiles_out.zip", FileMode.Create))
 3    {
 4        using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
 5        {
 6            using (FileStream source2 = File.Open(dataDir + "asyoulik.txt", FileMode.Open, FileAccess.Read))
 7            {
 8                using (var archive = new Archive())
 9                {
10                    archive.CreateEntry("alice29.txt", source1);
11                    archive.CreateEntry("asyoulik.txt", source2);
12                    //Define the parallelism criterion
13                    var parallelOptions = new ParallelOptions
14                    {
15                        ParallelCompressInMemory = ParallelCompressionMode.Always
16                    };
17                    archive.Save(zipFile,
18                        new ArchiveSaveOptions()
19                        {
20                            ParallelOptions = parallelOptions,
21                            Encoding = Encoding.ASCII,
22                            ArchiveComment = "There are two poems from Canterbury corpus"
23                        });
24                }
25            }
26        }
27    }
28

Compresión LZMA dentro del archivo ZIP

El algoritmo de cadena Lempel-Ziv-Markov (LZMA) es un algoritmo que se utiliza para realizar compresión de datos sin pérdidas. LZMA utiliza un algoritmo de compresión de diccionario, el flujo comprimido es un flujo de bits. La compresión LZMA dentro del archivo ZIP permite que los contenedores ZIP contengan entradas comprimidas LZMA. El siguiente ejemplo de código muestra la implementación de la compresión LZMA utilizando la API Aspose.ZIP.

Pasos: Compresión LZMA dentro del archivo ZIP usando C#

  1. Abra una secuencia de archivos con FileMode.Create con el nombre deseado de su archivo zip de salida.
  2. Cree una instancia de ArchiveEntrySettings y pásele la instancia de la clase LzmaCompressionSettings.
  3. Cree una instancia de la clase Archive y pásele la instancia de ArchiveEntrySettings creada anteriormente.
  4. Agregue archivos de datos para comprimirlos a través de rutas de archivo usando el método Archive.CreateEntry.
  5. Comprima los archivos de datos usando el método Archive.Save.
1    using (FileStream zipFile = File.Open(dataDir + "LZMACompression_out.zip", FileMode.Create))
2    {
3        using (Archive archive = new Archive(new ArchiveEntrySettings(new LzmaCompressionSettings())))
4        {
5            archive.CreateEntry("sample.txt", dataDir + "sample.txt");
6            archive.Save(zipFile);
7        }
8    }

Compresión BZip2 dentro del archivo ZIP

La configuración de compresión BZip2 permite que el contenedor ZIP contenga entradas comprimidas BZip2. El siguiente ejemplo de código muestra la implementación de la compresión BZip2 utilizando la API Aspose.ZIP.

Pasos: Compresión BZip2 dentro del archivo ZIP usando C#

  1. Abra una secuencia de archivos con FileMode.Create con el nombre deseado de su archivo zip de salida.
  2. Cree una instancia de ArchiveEntrySettings y pásele la instancia de la clase Bzip2CompressionSettings.
  3. Cree una instancia de la clase Archive y pásele la instancia de ArchiveEntrySettings creada anteriormente.
  4. Agregue archivos de datos para comprimirlos a través de rutas de archivo usando el método Archive.CreateEntry.
  5. Comprima los archivos de datos usando el método Archive.Save.
1    using (FileStream zipFile = File.Open(dataDir + "Bzip2Compression_out.zip", FileMode.Create))
2    {
3        using (Archive archive = new Archive(new ArchiveEntrySettings(new Bzip2CompressionSettings())))
4        {
5            archive.CreateEntry("sample.txt", dataDir + "sample.txt");
6            archive.Save(zipFile);
7        }
8    }    
9

Compresión PPMd dentro del archivo ZIP

La configuración de compresión PPMd permite que el contenedor ZIP contenga entradas comprimidas PPMd. El siguiente ejemplo de código demostró la implementación de la compresión PPMd utilizando la API Aspose.ZIP.

Pasos: Compresión PPMd dentro del archivo ZIP usando C#

  1. Abra una secuencia de archivos con FileMode.Create con el nombre deseado de su archivo zip de salida.
  2. Cree una instancia de ArchiveEntrySettings y pásele la instancia de la clase PPMdCompressionSettings.
  3. Cree una instancia de la clase Archive y pásele la instancia de ArchiveEntrySettings creada anteriormente.
  4. Agregue archivos de datos para comprimirlos a través de rutas de archivo usando el método Archive.CreateEntry.
  5. Comprima los archivos de datos usando el método Archive.Save.
1    using (FileStream zipFile = File.Open(dataDir + "PPMdCompression_out.zip", FileMode.Create))
2    {
3        using (Archive archive = new Archive(new ArchiveEntrySettings(new PPMdCompressionSettings())))
4        {
5            archive.CreateEntry("sample.txt", dataDir + "sample.txt");
6            archive.Save(zipFile);
7        }
8    }    
9

Descomprimiendo archivos

Descomprimir archivo con un solo archivo

Pasos: Descomprimir un único archivo de un archivo usando C#

  1. Abra una secuencia de archivos para el archivo ZIP de entrada usando FileMode.OpenRead.
  2. Cree una instancia de la clase Archive pasando la secuencia del archivo al constructor.
  3. Supervise el progreso de la descompresión utilizando el evento ExtractionProgressed de la entrada del archivo.
  4. Extraiga el archivo único del archivo utilizando el método Extraer, especificando la ruta del archivo de salida.
  5. Muestra el progreso de la descompresión como porcentaje en la consola.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream fs = File.OpenRead(dataDir + "CompressSingleFile_out.zip"))
 3    {
 4        using (Archive archive = new Archive(fs))
 5        {
 6            int percentReady = 0;
 7            archive.Entries[0].ExtractionProgressed += (s, e) =>
 8            {
 9                int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
10                if (percent > percentReady)
11                {
12                    Console.WriteLine(string.Format("{0}% decompressed", percent));
13                    percentReady = percent;
14                }
15            };
16            archive.Entries[0].Extract(dataDir + "alice_extracted_out.txt");
17        }
18    }    
19

Descomprimir archivo que tenga varios archivos

Pasos: Descomprima varios archivos de un archivo comprimido usando C#< /fuerte>

  1. Abra una secuencia de archivos para el archivo ZIP de entrada usando FileMode.Open.
  2. Cree una instancia de la clase Archive con opciones de carga personalizadas para enumerar entradas y realizar un seguimiento del progreso de la descompresión.
  3. Muestre los nombres de todas las entradas del archivo utilizando el evento EntryListed.
  4. Supervise el progreso de la descompresión con el evento EntryExtractionProgressed, que muestra el progreso en la consola.
  5. Extraiga varios archivos del archivo, utilizando el método Extraer y leyendo datos en los archivos de salida.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Open))
 3    {
 4        StringBuilder sb = new StringBuilder("Entries are: ");
 5        int percentReady = 0;
 6        using (Archive archive = new Archive(zipFile,
 7            new ArchiveLoadOptions()
 8            {
 9                EntryListed = (s, e) => { sb.AppendFormat("{0}, ", e.Entry.Name); },
10                EntryExtractionProgressed = (s, e) =>
11                {
12                    int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
13                    if (percent > percentReady)
14                    {
15                        Console.WriteLine(string.Format("{0}% compressed", percent)); percentReady = percent;
16                    }
17                }
18            }))
19        {
20            Console.WriteLine(sb.ToString(0, sb.Length - 2));
21            using (var extracted = File.Create(dataDir + "alice_extracted_out.txt"))
22            {
23                using (var decompressed = archive.Entries[0].Open())
24                {
25                    byte[] buffer = new byte[8192];
26                    int bytesRead;
27                    while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
28                    {
29                        extracted.Write(buffer, 0, bytesRead);
30                    }
31                    // Read from decompressed stream to extracting file.
32                }
33            }
34            percentReady = 0;
35            archive.Entries[1].Extract(dataDir + "asyoulik_extracted_out.txt");
36        }
37    }    
38

Extraer archivo almacenado sin compresión

Pasos: Extraer archivos de un archivo comprimido y guardarlos en el disco usando C#

  1. Abra el archivo ZIP y cree una instancia de la clase Archivo.
  2. Extraiga el primer archivo del archivo abriendo la secuencia de la entrada y escribiendo su contenido en un archivo nuevo.
  3. Utilice un búfer para leer datos del flujo descomprimido y guardarlos en el archivo de salida.
  4. Repita el proceso para el segundo archivo del archivo, escribiendo su contenido en un archivo de salida independiente.
 1    // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
 2    using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Open))
 3    {
 4        using (Archive archive = new Archive(zipFile))
 5        {
 6            using (var extracted = File.Create(dataDir + "alice_extracted_store_out.txt"))
 7            {
 8                using (var decompressed = archive.Entries[0].Open())
 9                {
10                    byte[] buffer = new byte[8192];
11                    int bytesRead;
12                    while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
13                    {
14                        extracted.Write(buffer, 0, bytesRead);
15                    }
16                    // Read from decompressed stream to extracting file.
17                }
18            }
19
20            using (var extracted = File.Create(dataDir + "asyoulik_extracted_store_out.txt"))
21            {
22                using (var decompressed = archive.Entries[1].Open())
23                {
24                    byte[] buffer = new byte[8192];
25                    int bytesRead;
26                    while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
27                    {
28                        extracted.Write(buffer, 0, bytesRead);
29                    }
30                    // Read from decompressed stream to extracting file.
31                }
32            }
33        }
34    }    
35
Cómo Extracción de archivos RAR
Subscribe to Aspose Product Updates

Get monthly newsletters & offers directly delivered to your mailbox.

© Aspose Pty Ltd 2001-2024. All Rights Reserved.