Dans le paysage numérique actuel, où la gestion des données est primordiale, disposer d'outils efficaces pour la compression et la décompression est crucial. Un tel outil qui se distingue dans l'écosystème .NET est SharpZipLib. Dans cet article, nous allons approfondir SharpZipLib, explorer ses fonctionnalités, ses applications, et comment l'intégrer dans vos projets .NET.

Qu'est-ce que SharpZipLib?

SharpZipLib est une bibliothèque de compression open-source riche en fonctionnalités pour .NET, écrite entièrement en C#. Il offre un support complet pour divers formats de compression, y compris ZIP, GZip, et Tar. Développé par une communauté dévouée, SharpZipLib offre un large éventail de fonctionnalités pour compresser et décompresser des fichiers efficacement.

Fonctionnalités et Capacités

1. Support de multiples formats de compression : SharpZipLib supporte les formats de compression populaires comme ZIP, GZip et Tar, répondant à divers cas d'utilisation et besoins.
2. Opérations basées sur les flux : La bibliothèque fonctionne sur des flux, permettant aux développeurs de travailler avec des données provenant de diverses sources, y compris des fichiers, des flux de mémoire ou des flux réseau. Cette flexibilité facilite l'intégration transparente dans différentes parties d'une application.
3. Niveaux de compression : Les développeurs peuvent ajuster les niveaux de compression pour équilibrer le ratio de compression et la vitesse de traitement, sur la base de leurs besoins spécifiques.
4. Protection par mot de passe : SharpZipLib permet la création d'archives ZIP protégées par mot de passe, garantissant la sécurité des données en cryptant le contenu avec un mot de passe spécifié.
5. Gestion et récupération d'erreurs : Des mécanismes robustes de gestion d'erreurs permettent aux développeurs de gérer gracieusement les exceptions lors des opérations de compression et de décompression. En outre, SharpZipLib supporte la récupération d'archives corrompues, améliorant la fiabilité.

Cas d'utilisation

1. Compression et archivage de fichiers : SharpZipLib est idéal pour les applications nécessitant la compression et l'archivage de fichiers, telles que les utilitaires de sauvegarde, les outils de gestion de fichiers ou les fonctionnalités d'exportation de données.
2. Services et API Web : Les services Web traitant des transferts de fichiers ou des échanges de données bénéficient souvent de la compression pour réduire l'utilisation de la bande passante. SharpZipLib peut être intégré sans problème dans de tels services pour compresser les données sortantes ou décompresser les charges utiles entrantes efficacement.
3. Applications de bureau : Les applications de bureau traitant de grandes quantités de données ou de fichiers de ressources peuvent utiliser SharpZipLib pour compresser les fichiers pour le stockage ou la distribution. Cela est particulièrement utile pour les installateurs de logiciels ou les outils de synchronisation de données.
4. Sauvegarde et stockage de données : Les applications nécessitant des sauvegardes périodiques ou de stockage de données au format compressé peuvent automatiser le processus de sauvegarde et économiser de l'espace de stockage efficacement en utilisant SharpZipLib.

Avantages de SharpZipLib

1. Open Source : En tant que bibliothèque open-source, SharpZipLib encourage la collaboration et les contributions de la communauté, assurant une amélioration continue et une adaptabilité aux besoins évolutifs.
2. Compatibilité multiplateforme : SharpZipLib, étant écrit en C# et visant le framework .NET, est compatible avec diverses plateformes, y compris Windows, Linux et macOS, améliorant sa polyvalence.
3. Léger et efficace : SharpZipLib est conçu pour être léger et efficace, minimisant la consommation de ressources tout en offrant des capacités de compression et décompression haute performance.
4. Documentation et support étendus : Une documentation complète et un support communautaire facilitent l'intégration pour les développeurs et la résolution des problèmes lors de l'utilisation de SharpZipLib.

Créer un projet C# dans Visual Studio

1. Ouvrez Visual Studio et cliquez sur l'option "Créer un nouveau projet".

2. Choisissez le modèle de projet approprié en fonction de vos besoins (par exemple, application console, application Windows Forms).

   

3. Spécifiez le nom et l'emplacement du projet, puis cliquez sur "Suivant".

   

4. Dans les Informations supplémentaires, sélectionnez la dernière version du Framework .NET. Cliquez sur "Créer" pour créer le projet.

Processus d'installation

Pour intégrer SharpZipLib dans votre projet .NET :

1. Dans votre IDE Visual Studio C# ConsoleApp, cliquez avec le bouton droit de la souris sur votre projet dans l'Explorateur de solutions et sélectionnez "Gérer les packages NuGet..."

2. Dans la fenêtre du gestionnaire de packages NuGet, recherchez "SharpZipLib".

   

3. Sélectionnez "SharpZipLib" dans les résultats de recherche et cliquez sur le bouton "Installer".

4. NuGet téléchargera et ajoutera automatiquement les dépendances nécessaires à votre projet.

Exemple de code

Voici un exemple simplifié montrant comment utiliser SharpZipLib pour compresser et décompresser des fichiers :

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 a longtemps été un pilier dans la communauté de développement du langage .NET, fournissant des fonctionnalités essentielles pour travailler avec des archives compressées telles que ZIP, GZip, Tar et BZip2. Cependant, à mesure que la technologie évolue et que les développeurs recherchent des solutions plus avancées, certaines limitations de SharpZipLib sont devenues apparentes.

Limitations de SharpZipLib

1. Complexité : L'API de SharpZipLib peut être lourde et verbeuse, obligeant les développeurs à écrire du code long pour effectuer des tâches simples telles que la création ou l'extraction d'archives ZIP.
2. Absence de fonctionnalités modernes : SharpZipLib ne prend pas en charge les fonctionnalités et plateformes .NET modernes, ce qui le rend moins adapté aux environnements de développement contemporains.
3. Documentation limitée : Bien que SharpZipLib existe depuis longtemps, sa documentation est souvent lacunaire et obsolète, ce qui rend difficile pour les développeurs de démarrer ou de résoudre les problèmes.
4. Performances : Les performances de SharpZipLib peuvent ne pas toujours répondre aux attentes des développeurs, en particulier lors du traitement d'archives volumineuses ou complexes.

IronZIP : combler les lacunes

IronZIP Documentation, développé par Iron Software Overview, est une solution moderne et efficace pour la gestion des archives ZIP dans les applications .NET. Avec son API intuitive, les développeurs peuvent facilement créer, lire et manipuler des fichiers ZIP. IronZIP offre des fonctionnalités avancées comme des niveaux de compression personnalisables et la protection par mot de passe, garantissant flexibilité et sécurité des données. Compatible avec les dernières versions de .NET et optimisé pour les performances, IronZIP simplifie les tâches de gestion des archives avec aisance et efficacité.

Caractéristiques d'IronZIP émerge comme une solution robuste et moderne qui répond aux lacunes de SharpZipLib. Voici comment IronZIP comble ces lacunes :

1. API avancée : IronZIP offre une API intuitive et conviviale pour les développeurs qui simplifie les tâches de gestion des archives. Avec IronZIP, les développeurs peuvent réaliser des opérations complexes en seulement quelques lignes de code, réduisant ainsi le temps et l'effort de développement.
2. Prise en charge complète de .NET : IronZIP prend entièrement en charge les dernières versions de .NET , notamment .NET Core, .NET Standard et .NET Framework, assurant ainsi la compatibilité avec les environnements et plateformes de développement modernes.
3. Documentation complète : IronZIP est fourni avec une documentation complète et des exemples, permettant aux développeurs de saisir rapidement ses fonctionnalités et ses capacités. La documentation étendue aide à réduire la courbe d'apprentissage et facilite l'intégration rapide dans les projets.
4. Contrôle du niveau de compression : IronZIP offre aux développeurs un contrôle sur le niveau de compression, leur permettant d'ajuster ce niveau en fonction de leurs besoins. Cette fonctionnalité permet aux développeurs d'équilibrer la réduction de la taille des fichiers et la vitesse de compression.
5. Protection par mot de passe : IronZIP prend en charge la protection par mot de passe des archives ZIP, renforçant ainsi la sécurité des données sensibles. Les développeurs peuvent facilement crypter les archives ZIP avec des mots de passe traditionnels, AES128 et AES256, garantissant que seuls les utilisateurs autorisés peuvent accéder au contenu de l'archive.
6. Optimisation des performances : IronZIP est optimisé pour les performances, offrant des vitesses de compression et d'extraction plus rapides que SharpZipLib. Cette optimisation garantit que les développeurs peuvent manipuler efficacement de grandes quantités de données sans compromettre les performances.

Explorez la documentation d'IronZIP pour plus d'informations sur la prise en main d'IronZIP. Les exemples de code d'IronZIP vous aident à démarrer sans aucune difficulté.

Installation d'IronZIP

Voici les étapes pour intégrer XDocument avec IronPDF :

• Ouvrez Visual Studio IDE ou votre IDE préféré.

• Dans le menu Outils, accédez à la console du gestionnaire de packages NuGet.

• Exécutez la commande suivante pour installer le package IronZIP :

  PM > Install-Package IronPdf

• Alternativement, vous pouvez l'installer depuis le gestionnaire de packages NuGet pour Solutions.

• Sélectionnez IronZIP depuis l'onglet de recherche de NuGet et cliquez sur installer :

Exemple de code

Le code source suivant montre comment IronZIP crée efficacement un fichier ZIP avec IronZIP en toute simplicité et en seulement quelques lignes de code. Ici, vous pouvez ajouter plusieurs fichiers à l'archive ZIP protégée par mot de passe en fournissant les noms de fichiers dans le dossier spécifié. Lors de la création de l'objet IronZipArchive, vous pouvez également spécifier le niveau de compression pour réduire la taille du fichier de sortie.

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

Fichier ZIP de sortie

Conclusion

Aperçu de SharpZipLib émerge comme une bibliothèque de compression puissante pour .NET, offrant un riche ensemble de fonctionnalités et capacités pour gérer les fichiers compressés efficacement. Que ce soit pour compresser des données pour le stockage, archiver des fichiers, ou optimiser l'utilisation de la bande passante dans les services web, SharpZipLib fournit les outils nécessaires pour simplifier les opérations de compression et de décompression. Avec sa nature open-source, sa compatibilité multiplateforme, et sa fonctionnalité robuste, SharpZipLib reste un choix de premier ordre pour les développeurs à la recherche d'une solution fiable pour les tâches de compression dans leurs applications .NET.

Bien que SharpZipLib ait été un choix fiable pour travailler avec des archives compressées dans les applications .NET, ses limitations sont devenues de plus en plus apparentes dans le paysage de développement actuel. Explorez l'API d'IronZIP prend le relais pour combler les lacunes laissées par SharpZipLib, offrant une alternative moderne et riche en fonctionnalités qui privilégie la facilité d'utilisation, la performance et la compatibilité. Avec IronZIP, les développeurs peuvent débloquer de nouvelles possibilités dans la gestion des archives et rationaliser leur flux de travail de développement avec des capacités avancées et une API intuitive.

IronZIP fournit une vue d'ensemble de licence d'essai gratuite. Téléchargez la bibliothèque depuis IronZIP Downloads et essayez-la.