Sharpziplib Extract ZIP C# (Cómo Funciona para Desarrolladores)

¿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.

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 C# Visual Studio

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

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 verbosa, requiriendo que los desarrolladores escriban código extenso para realizar tareas simples como crear o extraer archivos ZIP.
2. Falta de Características Modernas: SharpZipLib carece de soporte para funciones y plataformas modernas de .NET, lo que lo hace menos adecuado para entornos de desarrollo contemporáneos.
3. Documentación Limitada: Aunque SharpZipLib ha existido durante mucho tiempo, su documentación es a menudo escasa y desactualizada, lo que dificulta que los desarrolladores comiencen o resuelvan problemas.
4. Rendimiento: El rendimiento de SharpZipLib puede no siempre cumplir 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 amigable 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. Soporte Completo para .NET: IronZIP soporta completamente las últimas versiones de .NET, incluyendo .NET Core, .NET Standard y .NET Framework, asegurando compatibilidad con entornos y plataformas de desarrollo modernos.
3. Documentación Completa: IronZIP viene con documentación completa y ejemplos, permitiendo que los desarrolladores comprendan 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 de Nivel de Compresión: IronZIP proporciona a los desarrolladores control sobre el nivel de compresión, permitiéndoles ajustar el nivel de compresión según sus requerimientos. 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 soporta protección con contraseña para archivos ZIP, mejorando la seguridad para datos sensibles. 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.

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

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.