En el panorama digital actual, donde la gestión de datos es primordial, tener herramientas eficientes para compresión y descompresión es crucial. Una herramienta que destaca en el ecosistema de .NET es SharpZipLib. En este artículo, profundizaremos en SharpZipLib, explorando sus características, aplicaciones y cómo integrarlo en tus proyectos .NET.

¿Qué es SharpZipLib?

SharpZipLib es una biblioteca de compresión de código abierto y rica en funciones para .NET, escrita completamente en C#. Proporciona soporte completo para varios formatos de compresión, incluidos ZIP, GZip y Tar. Desarrollado por una comunidad dedicada, SharpZipLib ofrece una amplia gama de funcionalidades para comprimir y descomprimir archivos de manera eficiente.

Características y capacidades

1. Soporte para Múltiples Formatos de Compresión: SharpZipLib soporta formatos de compresión populares como ZIP, GZip y Tar, atendiendo a diversos casos de uso y requisitos.
2. Operaciones Basadas en Flujos: La biblioteca opera sobre flujos, permitiendo a los desarrolladores trabajar con datos de diversas fuentes, incluidos archivos, flujos de memoria o flujos de red. Esta flexibilidad facilita la integración sin problemas en diferentes partes de una aplicación.
3. Niveles de Compresión: Los desarrolladores pueden ajustar los niveles de compresión para equilibrar entre la relación de compresión y la velocidad de procesamiento, según sus necesidades específicas.
4. Protección con Contraseña: SharpZipLib permite la creación de archivos ZIP protegidos con contraseña, asegurando la seguridad de los datos al encriptar los contenidos con una contraseña especificada.
5. Manejo y Recuperación de Errores: Mecanismos robustos de manejo de errores permiten a los desarrolladores manejar elegantemente las excepciones durante las operaciones de compresión y descompresión. Además, SharpZipLib soporta la recuperación de archivos corruptos, aumentando la fiabilidad.

Casos de uso

1. Compresión y Archivado de Archivos: SharpZipLib es ideal para aplicaciones que requieren comprimir y archivar archivos, como utilidades de respaldo, herramientas de gestión de archivos o funcionalidades de exportación de datos.
2. Servicios Web y APIs: Los servicios web que tratan con transferencias de archivo o intercambio de datos a menudo se benefician de la compresión para reducir el uso de ancho de banda. SharpZipLib se puede integrar sin problemas en tales servicios para comprimir datos salientes o descomprimir paquetes entrantes de manera eficiente.
3. Aplicaciones de Escritorio: Las aplicaciones de escritorio que manejan grandes conjuntos de datos o archivos de recursos pueden aprovechar SharpZipLib para comprimir archivos para almacenamiento o distribución. Esto es particularmente útil para instaladores de software o herramientas de sincronización de datos.
4. Respaldo y Almacenamiento de Datos: Las aplicaciones que requieren respaldos periódicos o almacenamiento de datos en formato comprimido pueden automatizar el proceso de respaldo y conservar espacio de almacenamiento de manera efectiva usando SharpZipLib.

Ventajas de SharpZipLib

1. Código Abierto: Como una biblioteca de código abierto, SharpZipLib fomenta la colaboración y las contribuciones de la comunidad, asegurando una mejora continua y adaptabilidad a las necesidades cambiantes.
2. Compatibilidad Multiplataforma: SharpZipLib, al estar escrito en C# y dirigido al marco .NET, es compatible con varias plataformas, incluidas Windows, Linux y macOS, aumentando su versatilidad.
3. Ligero y Eficiente: SharpZipLib está diseñado para ser ligero y eficiente, minimizando el consumo de recursos mientras ofrece capacidades de compresión y descompresión de alto rendimiento.
4. Documentación Extensa y Soporte: La documentación completa y el soporte comunitario facilitan la integración y la resolución de problemas para los desarrolladores al usar SharpZipLib.

Crear Proyecto de Visual Studio en C#

1. Abre Visual Studio y haz clic en la opción "Crear un nuevo proyecto".

2. Elige la plantilla de proyecto adecuada según tus necesidades (por ejemplo, Aplicación de Consola, Aplicación Windows Forms).

   

3. Especifica el nombre y la ubicación del proyecto, luego haz clic en "Siguiente".

   

4. Desde Información Adicional, selecciona el último Marco .NET. Haz clic en "Crear" para crear el proyecto.

Proceso de instalación

Para integrar SharpZipLib en tu proyecto .NET:

1. En tu IDE de Visual Studio C# ConsoleApp, haz clic derecho en tu proyecto en el Explorador de Soluciones y selecciona "Administrar Paquetes NuGet..."

2. En la ventana del Administrador de Paquetes NuGet, busca "SharpZipLib".

   

3. Selecciona "SharpZipLib" de los resultados de búsqueda y haz clic en el botón "Instalar".

4. NuGet descargará y añadirá automáticamente las dependencias necesarias a tu proyecto.

Ejemplo de código

Aquí hay un ejemplo simplificado que demuestra cómo usar SharpZipLib para comprimir y descomprimir archivos:

using ICSharpCode.SharpZipLib.Zip;
using System;
using System.IO;

namespace SharpZipLibExample
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceDirectory = @"C:\SourceDirectory";     // Source directory containing files to compress
            string zipFilePath = @"C:\OutputDirectory\compressed.zip"; // Output path for the compressed ZIP file

            // Compress files from the source directory
            CompressDirectory(sourceDirectory, zipFilePath);
            Console.WriteLine("Files compressed successfully.");

            string extractPath = @"C:\OutputDirectory\extracted"; // Path to extract the decompressed files

            // Decompress files from the ZIP archive
            Decompress(zipFilePath, extractPath);
            Console.WriteLine("Files decompressed successfully.");
        }

        // Method to compress all files in a directory to a ZIP file
        static void CompressDirectory(string sourceDirectory, string zipFilePath)
        {
            using (var zipOutputStream = new ZipOutputStream(File.Create(zipFilePath)))
            {
                zipOutputStream.SetLevel(5); // Set compression level (0-9), 5 as a mid-range

                // Recursively add files in the source directory to the ZIP file
                AddDirectoryFilesToZip(sourceDirectory, zipOutputStream);

                zipOutputStream.Finish();
                zipOutputStream.Close();
            }
        }

        // Method to add files from a directory to a ZIP output stream
        static void AddDirectoryFilesToZip(string sourceDirectory, ZipOutputStream zipOutputStream)
        {
            // Get list of files in the directory
            string[] files = Directory.GetFiles(sourceDirectory);

            foreach (string file in files)
            {
                var entry = new ZipEntry(Path.GetFileName(file)); // Create a new entry for each file
                zipOutputStream.PutNextEntry(entry);

                using (var fileStream = File.OpenRead(file))
                {
                    // Buffer for reading files
                    byte[] buffer = new byte[4096];
                    int sourceBytes;

                    // Read file and write to ZIP stream
                    while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        zipOutputStream.Write(buffer, 0, sourceBytes);
                    }
                }
            }

            // Handle subdirectories recursively
            string[] subdirectories = Directory.GetDirectories(sourceDirectory);
            foreach (string subdirectory in subdirectories)
            {
                AddDirectoryFilesToZip(subdirectory, zipOutputStream);
            }
        }

        // Method to decompress files from a ZIP file
        static void Decompress(string zipFilePath, string extractPath)
        {
            using (var zipInputStream = new ZipInputStream(File.OpenRead(zipFilePath)))
            {
                ZipEntry entry;
                // Read entries from the ZIP archive
                while ((entry = zipInputStream.GetNextEntry()) != null)
                {
                    string entryPath = Path.Combine(extractPath, entry.Name);

                    // Process files
                    if (entry.IsFile)
                    {
                        string directoryName = Path.GetDirectoryName(entryPath);
                        if (!Directory.Exists(directoryName))
                            Directory.CreateDirectory(directoryName);

                        using (var fileStream = File.Create(entryPath))
                        {
                            // Buffer for reading entries
                            byte[] buffer = new byte[4096];
                            int bytesRead;
                            // Read from ZIP stream and write to file
                            while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
                            {
                                fileStream.Write(buffer, 0, bytesRead);
                            }
                        }
                    }
                    else if (entry.IsDirectory) // Process directories
                    {
                        Directory.CreateDirectory(entryPath);
                    }
                }
            }
        }
    }
}

using ICSharpCode.SharpZipLib.Zip;
using System;
using System.IO;

namespace SharpZipLibExample
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceDirectory = @"C:\SourceDirectory";     // Source directory containing files to compress
            string zipFilePath = @"C:\OutputDirectory\compressed.zip"; // Output path for the compressed ZIP file

            // Compress files from the source directory
            CompressDirectory(sourceDirectory, zipFilePath);
            Console.WriteLine("Files compressed successfully.");

            string extractPath = @"C:\OutputDirectory\extracted"; // Path to extract the decompressed files

            // Decompress files from the ZIP archive
            Decompress(zipFilePath, extractPath);
            Console.WriteLine("Files decompressed successfully.");
        }

        // Method to compress all files in a directory to a ZIP file
        static void CompressDirectory(string sourceDirectory, string zipFilePath)
        {
            using (var zipOutputStream = new ZipOutputStream(File.Create(zipFilePath)))
            {
                zipOutputStream.SetLevel(5); // Set compression level (0-9), 5 as a mid-range

                // Recursively add files in the source directory to the ZIP file
                AddDirectoryFilesToZip(sourceDirectory, zipOutputStream);

                zipOutputStream.Finish();
                zipOutputStream.Close();
            }
        }

        // Method to add files from a directory to a ZIP output stream
        static void AddDirectoryFilesToZip(string sourceDirectory, ZipOutputStream zipOutputStream)
        {
            // Get list of files in the directory
            string[] files = Directory.GetFiles(sourceDirectory);

            foreach (string file in files)
            {
                var entry = new ZipEntry(Path.GetFileName(file)); // Create a new entry for each file
                zipOutputStream.PutNextEntry(entry);

                using (var fileStream = File.OpenRead(file))
                {
                    // Buffer for reading files
                    byte[] buffer = new byte[4096];
                    int sourceBytes;

                    // Read file and write to ZIP stream
                    while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        zipOutputStream.Write(buffer, 0, sourceBytes);
                    }
                }
            }

            // Handle subdirectories recursively
            string[] subdirectories = Directory.GetDirectories(sourceDirectory);
            foreach (string subdirectory in subdirectories)
            {
                AddDirectoryFilesToZip(subdirectory, zipOutputStream);
            }
        }

        // Method to decompress files from a ZIP file
        static void Decompress(string zipFilePath, string extractPath)
        {
            using (var zipInputStream = new ZipInputStream(File.OpenRead(zipFilePath)))
            {
                ZipEntry entry;
                // Read entries from the ZIP archive
                while ((entry = zipInputStream.GetNextEntry()) != null)
                {
                    string entryPath = Path.Combine(extractPath, entry.Name);

                    // Process files
                    if (entry.IsFile)
                    {
                        string directoryName = Path.GetDirectoryName(entryPath);
                        if (!Directory.Exists(directoryName))
                            Directory.CreateDirectory(directoryName);

                        using (var fileStream = File.Create(entryPath))
                        {
                            // Buffer for reading entries
                            byte[] buffer = new byte[4096];
                            int bytesRead;
                            // Read from ZIP stream and write to file
                            while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
                            {
                                fileStream.Write(buffer, 0, bytesRead);
                            }
                        }
                    }
                    else if (entry.IsDirectory) // Process directories
                    {
                        Directory.CreateDirectory(entryPath);
                    }
                }
            }
        }
    }
}

Imports ICSharpCode.SharpZipLib.Zip
Imports System
Imports System.IO

Namespace SharpZipLibExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			Dim sourceDirectory As String = "C:\SourceDirectory" ' Source directory containing files to compress
			Dim zipFilePath As String = "C:\OutputDirectory\compressed.zip" ' Output path for the compressed ZIP file

			' Compress files from the source directory
			CompressDirectory(sourceDirectory, zipFilePath)
			Console.WriteLine("Files compressed successfully.")

			Dim extractPath As String = "C:\OutputDirectory\extracted" ' Path to extract the decompressed files

			' Decompress files from the ZIP archive
			Decompress(zipFilePath, extractPath)
			Console.WriteLine("Files decompressed successfully.")
		End Sub

		' Method to compress all files in a directory to a ZIP file
		Private Shared Sub CompressDirectory(ByVal sourceDirectory As String, ByVal zipFilePath As String)
			Using zipOutputStream As New ZipOutputStream(File.Create(zipFilePath))
				zipOutputStream.SetLevel(5) ' Set compression level (0-9), 5 as a mid-range

				' Recursively add files in the source directory to the ZIP file
				AddDirectoryFilesToZip(sourceDirectory, zipOutputStream)

				zipOutputStream.Finish()
				zipOutputStream.Close()
			End Using
		End Sub

		' Method to add files from a directory to a ZIP output stream
		Private Shared Sub AddDirectoryFilesToZip(ByVal sourceDirectory As String, ByVal zipOutputStream As ZipOutputStream)
			' Get list of files in the directory
			Dim files() As String = Directory.GetFiles(sourceDirectory)

			For Each file As String In files
				Dim entry = New ZipEntry(Path.GetFileName(file)) ' Create a new entry for each file
				zipOutputStream.PutNextEntry(entry)

				Using fileStream = System.IO.File.OpenRead(file)
					' Buffer for reading files
					Dim buffer(4095) As Byte
					Dim sourceBytes As Integer

					' Read file and write to ZIP stream
					sourceBytes = fileStream.Read(buffer, 0, buffer.Length)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
					Do While sourceBytes > 0
						zipOutputStream.Write(buffer, 0, sourceBytes)
						sourceBytes = fileStream.Read(buffer, 0, buffer.Length)
					Loop
				End Using
			Next file

			' Handle subdirectories recursively
			Dim subdirectories() As String = Directory.GetDirectories(sourceDirectory)
			For Each subdirectory As String In subdirectories
				AddDirectoryFilesToZip(subdirectory, zipOutputStream)
			Next subdirectory
		End Sub

		' Method to decompress files from a ZIP file
		Private Shared Sub Decompress(ByVal zipFilePath As String, ByVal extractPath As String)
			Using zipInputStream As New ZipInputStream(File.OpenRead(zipFilePath))
				Dim entry As ZipEntry
				' Read entries from the ZIP archive
				entry = zipInputStream.GetNextEntry()
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((entry = zipInputStream.GetNextEntry()) != null)
				Do While entry IsNot Nothing
					Dim entryPath As String = Path.Combine(extractPath, entry.Name)

					' Process files
					If entry.IsFile Then
						Dim directoryName As String = Path.GetDirectoryName(entryPath)
						If Not Directory.Exists(directoryName) Then
							Directory.CreateDirectory(directoryName)
						End If

						Using fileStream = File.Create(entryPath)
							' Buffer for reading entries
							Dim buffer(4095) As Byte
							Dim bytesRead As Integer
							' Read from ZIP stream and write to file
							bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
							Do While bytesRead > 0
								fileStream.Write(buffer, 0, bytesRead)
								bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)
							Loop
						End Using
					ElseIf entry.IsDirectory Then ' Process directories
						Directory.CreateDirectory(entryPath)
					End If
					entry = zipInputStream.GetNextEntry()
				Loop
			End Using
		End Sub
	End Class
End Namespace

Imports ICSharpCode.SharpZipLib.Zip
Imports System
Imports System.IO

Namespace SharpZipLibExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			Dim sourceDirectory As String = "C:\SourceDirectory" ' Source directory containing files to compress
			Dim zipFilePath As String = "C:\OutputDirectory\compressed.zip" ' Output path for the compressed ZIP file

			' Compress files from the source directory
			CompressDirectory(sourceDirectory, zipFilePath)
			Console.WriteLine("Files compressed successfully.")

			Dim extractPath As String = "C:\OutputDirectory\extracted" ' Path to extract the decompressed files

			' Decompress files from the ZIP archive
			Decompress(zipFilePath, extractPath)
			Console.WriteLine("Files decompressed successfully.")
		End Sub

		' Method to compress all files in a directory to a ZIP file
		Private Shared Sub CompressDirectory(ByVal sourceDirectory As String, ByVal zipFilePath As String)
			Using zipOutputStream As New ZipOutputStream(File.Create(zipFilePath))
				zipOutputStream.SetLevel(5) ' Set compression level (0-9), 5 as a mid-range

				' Recursively add files in the source directory to the ZIP file
				AddDirectoryFilesToZip(sourceDirectory, zipOutputStream)

				zipOutputStream.Finish()
				zipOutputStream.Close()
			End Using
		End Sub

		' Method to add files from a directory to a ZIP output stream
		Private Shared Sub AddDirectoryFilesToZip(ByVal sourceDirectory As String, ByVal zipOutputStream As ZipOutputStream)
			' Get list of files in the directory
			Dim files() As String = Directory.GetFiles(sourceDirectory)

			For Each file As String In files
				Dim entry = New ZipEntry(Path.GetFileName(file)) ' Create a new entry for each file
				zipOutputStream.PutNextEntry(entry)

				Using fileStream = System.IO.File.OpenRead(file)
					' Buffer for reading files
					Dim buffer(4095) As Byte
					Dim sourceBytes As Integer

					' Read file and write to ZIP stream
					sourceBytes = fileStream.Read(buffer, 0, buffer.Length)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
					Do While sourceBytes > 0
						zipOutputStream.Write(buffer, 0, sourceBytes)
						sourceBytes = fileStream.Read(buffer, 0, buffer.Length)
					Loop
				End Using
			Next file

			' Handle subdirectories recursively
			Dim subdirectories() As String = Directory.GetDirectories(sourceDirectory)
			For Each subdirectory As String In subdirectories
				AddDirectoryFilesToZip(subdirectory, zipOutputStream)
			Next subdirectory
		End Sub

		' Method to decompress files from a ZIP file
		Private Shared Sub Decompress(ByVal zipFilePath As String, ByVal extractPath As String)
			Using zipInputStream As New ZipInputStream(File.OpenRead(zipFilePath))
				Dim entry As ZipEntry
				' Read entries from the ZIP archive
				entry = zipInputStream.GetNextEntry()
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((entry = zipInputStream.GetNextEntry()) != null)
				Do While entry IsNot Nothing
					Dim entryPath As String = Path.Combine(extractPath, entry.Name)

					' Process files
					If entry.IsFile Then
						Dim directoryName As String = Path.GetDirectoryName(entryPath)
						If Not Directory.Exists(directoryName) Then
							Directory.CreateDirectory(directoryName)
						End If

						Using fileStream = File.Create(entryPath)
							' Buffer for reading entries
							Dim buffer(4095) As Byte
							Dim bytesRead As Integer
							' Read from ZIP stream and write to file
							bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
							Do While bytesRead > 0
								fileStream.Write(buffer, 0, bytesRead)
								bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)
							Loop
						End Using
					ElseIf entry.IsDirectory Then ' Process directories
						Directory.CreateDirectory(entryPath)
					End If
					entry = zipInputStream.GetNextEntry()
				Loop
			End Using
		End Sub
	End Class
End Namespace

SharpZipLib ha sido durante mucho tiempo un elemento básico en la comunidad de desarrollo de lenguaje .NET, proporcionando funcionalidad esencial para trabajar con archivos comprimidos como ZIP, GZip, Tar y BZip2. Sin embargo, a medida que la tecnología evoluciona y los desarrolladores buscan soluciones más avanzadas, se han hecho evidentes ciertas limitaciones de SharpZipLib.

Limitaciones de SharpZipLib

1. Complejidad: la API de SharpZipLib puede ser engorrosa y extensa, lo que requiere que los desarrolladores escriban código extenso para realizar tareas simples como crear o extraer archivos ZIP.
2. Falta de funciones modernas: SharpZipLib carece de soporte para las características y plataformas .NET modernas, lo que lo hace menos adecuado para los entornos de desarrollo contemporáneos.
3. Documentación limitada: si bien SharpZipLib existe desde hace mucho tiempo, su documentación suele ser escasa y obsoleta, lo que dificulta que los desarrolladores comiencen a utilizarla o solucionen problemas.
4. Rendimiento: Es posible que el rendimiento de SharpZipLib no siempre cumpla con las expectativas de los desarrolladores, especialmente cuando se trata de archivos grandes o complejos.

IronZIP: salvando las distancias

Documentación de IronZIP, desarrollada por Iron Software Overview, es una solución moderna y eficiente para la gestión de archivos ZIP en aplicaciones .NET. Con su intuitiva API, los desarrolladores pueden crear, leer y manipular archivos ZIP fácilmente. IronZIP ofrece características avanzadas como niveles de compresión personalizables y protección con contraseña, asegurando flexibilidad y seguridad de los datos. Compatible con las últimas versiones de .NET y optimizado para el rendimiento, IronZIP simplifica las tareas de gestión de archivos con facilidad y eficiencia.

Características de IronZIP surge como una solución robusta y moderna que aborda las deficiencias de SharpZipLib. Así es como IronZIP llena los vacíos:

1. API avanzada: IronZIP ofrece una API intuitiva y fácil de usar para desarrolladores que simplifica las tareas de gestión de archivos. Con IronZIP, los desarrolladores pueden realizar operaciones complejas con solo unas pocas líneas de código, reduciendo el tiempo y esfuerzo de desarrollo.
2. Compatibilidad total con .NET : IronZIP es totalmente compatible con las últimas versiones de .NET , incluidas .NET Core, .NET Standard y .NET Framework, lo que garantiza la compatibilidad con plataformas y entornos de desarrollo modernos.
3. Documentación completa: IronZIP viene con documentación y ejemplos completos, lo que permite a los desarrolladores comprender rápidamente sus características y capacidades. La extensa documentación ayuda a agilizar la curva de aprendizaje y facilita la integración rápida en los proyectos.
4. Control del nivel de compresión: IronZIP proporciona a los desarrolladores control sobre el nivel de compresión, lo que les permite ajustar el nivel de compresión según sus requisitos. Esta característica permite a los desarrolladores equilibrar entre la reducción del tamaño del archivo y la velocidad de compresión.
5. Protección con contraseña: IronZIP admite la protección con contraseña para archivos ZIP, lo que mejora la seguridad de los datos confidenciales. Los desarrolladores pueden encriptar fácilmente archivos ZIP con contraseñas tradicionales, AES128, y AES256, asegurando que solo los usuarios autorizados puedan acceder a los contenidos del archivo.
6. Optimización del rendimiento: IronZIP está optimizado para el rendimiento, ofreciendo velocidades de compresión y extracción más rápidas en comparación con SharpZipLib. Esta optimización asegura que los desarrolladores puedan manejar grandes volúmenes de datos de manera eficiente sin comprometer el rendimiento.

Explora la Documentación de IronZIP para más información sobre cómo empezar con IronZIP. Los Ejemplos de Código de IronZIP te ayudan a comenzar sin complicaciones.

Instalación de IronZIP

Aquí están los pasos para integrar XDocument con IronPDF:

• Abre IDE de Visual Studio o tu IDE preferido.

• Desde el menú Herramientas, navega hasta la Consola del Administrador de Paquetes NuGet.

• Ejecuta el siguiente comando para instalar el paquete IronZIP:

  PM > Install-Package IronPdf

• Alternativamente, puedes instalarlo desde el Administrador de Paquetes NuGet para Soluciones.

• Selecciona IronZIP desde la pestaña de exploración de NuGet y haz clic en instalar:

Ejemplo de código

El siguiente código fuente muestra cómo IronZIP eficientemente crea un archivo ZIP con IronZIP con facilidad y con solo unas pocas líneas de código. Aquí, puedes agregar múltiples archivos al archivo ZIP protegido con contraseña proporcionando los nombres de los archivos en la carpeta especificada. Al crear el objeto IronZipArchive también puede especificar el nivel de compresión para reducir el tamaño de espacio del archivo de salida.

using IronZip;
using IronZip.Enum;

class Program
{
    static void Main()
    {
        // Create an empty ZIP with the highest compression
        using (var archive = new IronZipArchive(9))
        {
            // Password protect the ZIP (Support AES128 & AES256)
            archive.SetPassword("P@ssw0rd", EncryptionMethods.Traditional);
            archive.AddArchiveEntry("./assets/file1.txt");
            archive.AddArchiveEntry("./assets/file2.txt");
            // Export the ZIP
            archive.SaveAs("output.zip");
        }
    }
}

using IronZip;
using IronZip.Enum;

class Program
{
    static void Main()
    {
        // Create an empty ZIP with the highest compression
        using (var archive = new IronZipArchive(9))
        {
            // Password protect the ZIP (Support AES128 & AES256)
            archive.SetPassword("P@ssw0rd", EncryptionMethods.Traditional);
            archive.AddArchiveEntry("./assets/file1.txt");
            archive.AddArchiveEntry("./assets/file2.txt");
            // Export the ZIP
            archive.SaveAs("output.zip");
        }
    }
}

Imports IronZip
Imports IronZip.Enum

Friend Class Program
	Shared Sub Main()
		' Create an empty ZIP with the highest compression
		Using archive = New IronZipArchive(9)
			' Password protect the ZIP (Support AES128 & AES256)
			archive.SetPassword("P@ssw0rd", EncryptionMethods.Traditional)
			archive.AddArchiveEntry("./assets/file1.txt")
			archive.AddArchiveEntry("./assets/file2.txt")
			' Export the ZIP
			archive.SaveAs("output.zip")
		End Using
	End Sub
End Class

Imports IronZip
Imports IronZip.Enum

Friend Class Program
	Shared Sub Main()
		' Create an empty ZIP with the highest compression
		Using archive = New IronZipArchive(9)
			' Password protect the ZIP (Support AES128 & AES256)
			archive.SetPassword("P@ssw0rd", EncryptionMethods.Traditional)
			archive.AddArchiveEntry("./assets/file1.txt")
			archive.AddArchiveEntry("./assets/file2.txt")
			' Export the ZIP
			archive.SaveAs("output.zip")
		End Using
	End Sub
End Class

Archivo Zip de salida

Conclusión

Resumen de SharpZipLib surge como una poderosa biblioteca de compresión para .NET, ofreciendo un conjunto rico de características y capacidades para manejar archivos comprimidos de manera eficiente. Ya sea comprimiendo datos para almacenamiento, archivando archivos, u optimizando el uso del ancho de banda en servicios web, SharpZipLib proporciona las herramientas necesarias para simplificar operaciones de compresión y descompresión. Con su naturaleza de código abierto, compatibilidad multiplataforma y funcionalidad robusta, SharpZipLib sigue siendo una opción principal para los desarrolladores que buscan una solución confiable para tareas de compresión en sus aplicaciones .NET.

Aunque SharpZipLib ha sido una opción confiable para trabajar con archivos comprimidos en aplicaciones .NET, sus limitaciones se han vuelto cada vez más evidentes en el panorama de desarrollo actual. Explora IronZIP API entra para llenar los vacíos dejados por SharpZipLib, ofreciendo una alternativa moderna y rica en funciones que prioriza la facilidad de uso, el rendimiento y la compatibilidad. Con IronZIP, los desarrolladores pueden desbloquear nuevas posibilidades en la gestión de archivos y agilizar su flujo de trabajo de desarrollo con capacidades avanzadas y una API intuitiva.

IronZIP proporciona una visión general de la licencia de prueba gratuita. Descarga la biblioteca desde IronZIP Downloads y pruébala.