Sharpziplib Extrair ZIP em C# (Como funciona para desenvolvedores)

O que é o SharpZipLib?

SharpZipLib é uma biblioteca de compressão de código aberto rica em recursos para .NET, escrita inteiramente em C#. Oferece suporte abrangente para diversos formatos de compressão, incluindo ZIP, GZip e Tar. Desenvolvida por uma comunidade dedicada, a SharpZipLib oferece uma ampla gama de funcionalidades para comprimir e descomprimir arquivos de forma eficiente.

Vantagens do SharpZipLib

1. Código aberto: Como uma biblioteca de código aberto, o SharpZipLib incentiva a colaboração e as contribuições da comunidade, garantindo melhoria contínua e adaptabilidade às necessidades em constante evolução.
2. Compatibilidade entre plataformas: O SharpZipLib, por ser escrito em C# e direcionado ao .NET Framework, é compatível com diversas plataformas, incluindo Windows, Linux e macOS, aumentando sua versatilidade.
3. Leve e eficiente: O SharpZipLib foi projetado para ser leve e eficiente, minimizando o consumo de recursos e, ao mesmo tempo, oferecendo recursos de compressão e descompressão de alto desempenho.
4. Documentação e suporte abrangentes: A documentação completa e o suporte da comunidade facilitam a integração e a resolução de problemas por parte dos desenvolvedores ao usar o SharpZipLib.

Criar Projeto C# no Visual Studio

1. Abra o Visual Studio e clique na opção "Criar um novo projeto".

2. Escolha o modelo de projeto apropriado com base em suas necessidades (por exemplo, Aplicativo de Console, Aplicativo Windows Forms).

   

3. Especifique o nome e a localização do projeto e clique em "Avançar".

   

4. Em Informações adicionais, selecione a versão mais recente do .NET Framework. Clique em "Criar" para criar o projeto.

Processo de instalação

Para integrar o SharpZipLib ao seu projeto .NET :

1. No seu aplicativo de console C# do Visual Studio IDE , clique com o botão direito do mouse no seu projeto no Solution Explorer e selecione "Gerenciar pacotes NuGet ..."

2. Na janela do Gerenciador de Pacotes NuGet , pesquise por "SharpZipLib".

   

3. Selecione "SharpZipLib" nos resultados da pesquisa e clique no botão "Instalar".
4. O NuGet fará o download e adicionará automaticamente as dependências necessárias ao seu projeto.

Exemplo de código

Aqui está um exemplo simplificado que demonstra como usar o SharpZipLib para compactar e descompactar arquivos:

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

A SharpZipLib tem sido, há muito tempo, um recurso essencial na comunidade de desenvolvimento da linguagem .NET , fornecendo funcionalidades fundamentais para trabalhar com arquivos compactados como ZIP, GZip, Tar e BZip2. No entanto, à medida que a tecnologia evolui e os desenvolvedores buscam soluções mais avançadas, certas limitações da SharpZipLib tornaram-se evidentes.

Limitações do SharpZipLib

1. Complexidade: A API do SharpZipLib pode ser complexa e verbosa, exigindo que os desenvolvedores escrevam códigos extensos para realizar tarefas simples, como criar ou extrair arquivos ZIP.
2. Falta de recursos modernos: o SharpZipLib não oferece suporte a recursos e plataformas .NET modernos, o que o torna menos adequado para ambientes de desenvolvimento contemporâneos.
3. Documentação limitada: Embora o SharpZipLib exista há bastante tempo, sua documentação costuma ser escassa e desatualizada, dificultando o início do uso ou a resolução de problemas por parte dos desenvolvedores.
4. Desempenho: O desempenho do SharpZipLib pode nem sempre atender às expectativas dos desenvolvedores, especialmente ao lidar com arquivos grandes ou complexos.

IronZIP: Unindo as Lacunas

A documentação do IronZIP , desenvolvido pela Iron Software , descreve uma solução moderna e eficiente para gerenciar arquivos ZIP em aplicações .NET . Com sua API intuitiva, os desenvolvedores podem criar, ler e manipular arquivos ZIP com facilidade. O IronZIP oferece recursos avançados, como níveis de compressão personalizáveis ​​e proteção por senha, garantindo flexibilidade e segurança de dados. Compatível com as versões mais recentes do .NET e otimizado para desempenho, o IronZIP simplifica as tarefas de gerenciamento de arquivos com facilidade e eficiência.

O IronZIP Features surge como uma solução robusta e moderna que resolve as deficiências do SharpZipLib. Eis como o IronZIP preenche as lacunas:

1. API avançada: O IronZIP oferece uma API intuitiva e amigável para desenvolvedores, que simplifica as tarefas de gerenciamento de arquivos. Com o IronZIP, os desenvolvedores podem realizar operações complexas com apenas algumas linhas de código, reduzindo o tempo e o esforço de desenvolvimento.
2. Suporte completo ao .NET : O IronZIP oferece suporte completo às versões mais recentes do .NET , incluindo .NET Core, .NET Standard e .NET Framework, garantindo compatibilidade com ambientes e plataformas de desenvolvimento modernos.
3. Documentação abrangente: O IronZIP vem com documentação e exemplos abrangentes, permitindo que os desenvolvedores compreendam rapidamente seus recursos e capacidades. A extensa documentação ajuda a simplificar a curva de aprendizado e facilita a rápida integração aos projetos.
4. Controle do nível de compressão: O IronZIP oferece aos desenvolvedores controle sobre o nível de compressão, permitindo que eles o ajustem de acordo com suas necessidades. Essa funcionalidade permite que os desenvolvedores encontrem um equilíbrio entre a redução do tamanho do arquivo e a velocidade de compressão.
5. Proteção por senha: O IronZIP oferece suporte à proteção por senha para arquivos ZIP, aumentando a segurança de dados confidenciais. Os desenvolvedores podem criptografar facilmente arquivos ZIP com senhas tradicionais, AES128 e AES256, garantindo que apenas usuários autorizados possam acessar o conteúdo do arquivo.
6. Otimização de desempenho: O IronZIP é otimizado para desempenho, oferecendo velocidades de compressão e extração mais rápidas em comparação com o SharpZipLib. Essa otimização garante que os desenvolvedores possam lidar com grandes volumes de dados de forma eficiente, sem comprometer o desempenho.

Explore a documentação do IronZIP para obter mais informações sobre como começar a usar o IronZIP. Os exemplos de código do IronZIP ajudam você a começar sem complicações.

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

Conclusão

A SharpZipLib surge como uma poderosa biblioteca de compressão para .NET, oferecendo um conjunto abrangente de recursos e funcionalidades para o gerenciamento eficiente de arquivos compactados. Seja para comprimir dados para armazenamento, arquivar arquivos ou otimizar o uso de largura de banda em serviços web, o SharpZipLib fornece as ferramentas necessárias para simplificar as operações de compressão e descompressão. Graças à sua natureza de código aberto, compatibilidade entre plataformas e funcionalidade robusta, o SharpZipLib continua sendo uma das principais opções para desenvolvedores que buscam uma solução confiável para tarefas de compressão em seus aplicativos .NET .

Embora o SharpZipLib tenha sido uma escolha confiável para trabalhar com arquivos compactados em aplicações .NET , suas limitações tornaram-se cada vez mais evidentes no cenário de desenvolvimento atual. Explore IronZIP API surge para preencher as lacunas deixadas pelo SharpZipLib, oferecendo uma alternativa moderna e rica em recursos que prioriza a facilidade de uso, o desempenho e a compatibilidade. Com o IronZIP, os desenvolvedores podem desbloquear novas possibilidades no gerenciamento de arquivos e otimizar seu fluxo de trabalho de desenvolvimento com recursos avançados e uma API intuitiva.

O IronZIP oferece uma visão geral do licenciamento de avaliação gratuita . Baixe a biblioteca do IronZIP Downloads e experimente.