Sharpziplib Extract ZIP C# (jak to działa dla programistów)

Czym jest SharpZipLib?

SharpZipLib to bogata w funkcje biblioteka kompresji typu open source dla platformy .NET, napisana w całości w języku C#. Zapewnia kompleksową obsługę różnych formatów kompresji, w tym ZIP, GZip i Tar. Opracowana przez zaangażowaną społeczność biblioteka SharpZipLib oferuje szeroki zakres funkcji umożliwiających wydajną kompresję i dekompresję plików.

Zalety SharpZipLib

1. Otwarte oprogramowanie: Jako biblioteka typu open source, SharpZipLib zachęca do współpracy i wkładu społeczności, zapewniając ciągłe ulepszanie i dostosowywanie się do zmieniających się potrzeb.
2. Kompatybilność międzyplatformowa: SharpZipLib, napisany w języku C# i przeznaczony dla .NET Framework, jest kompatybilny z różnymi platformami, w tym Windows, Linux i macOS, co zwiększa jego wszechstronność.
3. Lekki i wydajny: SharpZipLib został zaprojektowany tak, aby był lekki i wydajny, minimalizując zużycie zasobów przy jednoczesnym zapewnieniu wysokowydajnych funkcji kompresji i dekompresji.
4. Obszerna dokumentacja i wsparcie: Kompleksowa dokumentacja i wsparcie społeczności ułatwiają programistom integrację i rozwiązywanie problemów podczas korzystania z SharpZipLib.

Utwórz projekt C# w Visual Studio

1. Otwórz Visual Studio i kliknij opcję "Utwórz nowy projekt".

2. Wybierz odpowiedni szablon projektu w oparciu o swoje wymagania (np. aplikacja konsolowa, aplikacja Windows Forms).

   

3. Podaj nazwę projektu i lokalizację, a następnie kliknij "Dalej".

   

4. W sekcji "Dodatkowe informacje" wybierz najnowszą wersję .NET Framework. Kliknij "Utwórz", aby utworzyć projekt.

Proces instalacji

Aby zintegrować SharpZipLib z projektem .NET:

1. W aplikacji konsolowej C# w środowisku Visual Studio kliknij prawym przyciskiem myszy swój projekt w Eksploratorze rozwiązań i wybierz opcję "Zarządzaj pakietami NuGet...".

2. W oknie NuGet Package Manager wyszukaj "SharpZipLib".

   

3. Wybierz "SharpZipLib" z wyników wyszukiwania i kliknij przycisk "Zainstaluj".
4. NuGet automatycznie pobierze i doda niezbędne zależności do Twojego projektu.

Przyklad kodu

Oto uproszczony przykład pokazujący, jak używać SharpZipLib do kompresji i dekompresji plików:

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 od dawna jest podstawowym narzędziem w społeczności programistów języka .NET, zapewniając niezbędną funkcjonalność do pracy ze skompresowanymi archiwami, takimi jak ZIP, GZip, Tar i BZip2. Jednak wraz z rozwojem technologii i poszukiwaniem przez programistów bardziej zaawansowanych rozwiązań, pewne ograniczenia SharpZipLib stały się widoczne.

Ograniczenia biblioteki SharpZipLib

1. Złożoność: API biblioteki SharpZipLib może być uciążliwe i rozbudowane, co wymaga od programistów pisania długiego kodu w celu wykonania prostych zadań, takich jak tworzenie lub rozpakowywanie archiwów ZIP.
2. Brak nowoczesnych funkcji: SharpZipLib nie obsługuje nowoczesnych funkcji i platform .NET, co sprawia, że jest mniej odpowiedni dla współczesnych środowisk programistycznych.
3. Ograniczona dokumentacja: Chociaż biblioteka SharpZipLib istnieje już od dawna, jej dokumentacja jest często skąpa i nieaktualna, co utrudnia programistom rozpoczęcie pracy lub rozwiązywanie problemów.
4. Wydajność: Wydajność SharpZipLib nie zawsze może spełniać oczekiwania programistów, zwłaszcza w przypadku dużych lub złożonych archiwów.

IronZIP: wypełnianie luki

Dokumentacja IronZIP, opracowana przez Iron Software Overview, stanowi nowoczesne i wydajne rozwiązanie do zarządzania archiwami ZIP w aplikacjach .NET. Dzięki intuicyjnemu interfejsowi API programiści mogą z łatwością tworzyć, odczytywać i modyfikować pliki ZIP. IronZIP oferuje zaawansowane funkcje, takie jak konfigurowalne poziomy kompresji i ochrona hasłem, zapewniając elastyczność i bezpieczeństwo danych. Kompatybilny z najnowszymi wersjami .NET i zoptymalizowany pod kątem wydajności, IronZIP usprawnia zadania związane z zarządzaniem archiwami, zapewniając łatwość i efektywność.

Funkcje IronZIP sprawiają, że jest to solidne i nowoczesne rozwiązanie, które eliminuje niedociągnięcia biblioteki SharpZipLib. Oto, w jaki sposób IronZIP wypełnia te luki:

1. Zaawansowany interfejs API: IronZIP oferuje intuicyjny i przyjazny dla programistów interfejs API, który upraszcza zadania związane z zarządzaniem archiwami. Dzięki IronZIP programiści mogą wykonywać złożone operacje za pomocą zaledwie kilku linii kodu, co skraca czas i zmniejsza nakład pracy związany z tworzeniem oprogramowania.
2. Pełna obsługa .NET: IronZIP w pełni obsługuje najnowsze wersje .NET, w tym .NET Core, .NET Standard i .NET Framework, zapewniając kompatybilność z nowoczesnymi środowiskami programistycznymi i platformami.
3. Kompleksowa dokumentacja: IronZIP zawiera obszerną dokumentację i przykłady, które pozwalają programistom szybko zapoznać się z jego funkcjami i możliwościami. Obszerna dokumentacja pomaga usprawnić proces nauki i ułatwia szybką integrację z projektami.
4. Kontrola poziomu kompresji: IronZIP zapewnia programistom kontrolę nad poziomem kompresji, umożliwiając im dostosowanie poziomu kompresji w zależności od ich wymagań. Ta funkcja pozwala programistom znaleźć równowagę między zmniejszeniem rozmiaru pliku a szybkością kompresji.
5. Ochrona hasłem: IronZIP obsługuje ochronę hasłem archiwów ZIP, zwiększając bezpieczeństwo wrażliwych danych. Programiści mogą łatwo szyfrować archiwa ZIP za pomocą tradycyjnych haseł oraz haseł AES128 i AES256, zapewniając, że dostęp do zawartości archiwum mają wyłącznie uprawnieni użytkownicy.
6. Optymalizacja wydajności: IronZIP jest zoptymalizowany pod kątem wydajności, zapewniając szybsze kompresowanie i rozpakowywanie w porównaniu z SharpZipLib. Ta optymalizacja gwarantuje, że programiści mogą efektywnie obsługiwać duże ilości danych bez utraty wydajności.

Zapoznaj się z dokumentacją IronZIP, aby uzyskać więcej informacji na temat rozpoczęcia pracy z IronZIP. Przykłady kodu IronZIP pomogą Ci rozpocząć pracę bez żadnych problemów.

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

Wnioski

SharpZipLib Overview to potężna biblioteka kompresji dla platformy .NET, oferująca bogaty zestaw funkcji i możliwości pozwalających na wydajną obsługę skompresowanych plików. Niezależnie od tego, czy chodzi o kompresję danych do przechowywania, archiwizację plików, czy optymalizację wykorzystania przepustowości w usługach internetowych, SharpZipLib zapewnia narzędzia niezbędne do usprawnienia operacji kompresji i dekompresji. Dzięki swojej otwartości, kompatybilności międzyplatformowej i solidnej funkcjonalności, SharpZipLib pozostaje najlepszym wyborem dla programistów poszukujących niezawodnego rozwiązania do kompresji w swoich aplikacjach .NET.

Chociaż SharpZipLib był niezawodnym wyborem do pracy ze skompresowanymi archiwami w aplikacjach .NET, jego ograniczenia stają się coraz bardziej widoczne w dzisiejszym środowisku programistycznym. Poznaj IronZIP API, które wypełnia luki pozostawione przez SharpZipLib, oferując nowoczesną i bogatą w funkcje alternatywę, która stawia na łatwość użytkowania, wydajność i kompatybilność. Dzięki IronZIP programiści mogą odkrywać nowe możliwości w zakresie zarządzania archiwami oraz usprawniać proces tworzenia oprogramowania dzięki zaawansowanym funkcjom i intuicyjnemu interfejsowi API.

IronZIP udostępnia bezpłatną wersję próbną z przeglądem licencji. Pobierz bibliotekę IronZIP z IronZIP Downloads i wypróbuj ją.