Extrayez des fichiers ZIP et créez des PDF avec IronPDF et SharpZipLib !
using System;
using System.IO;
using ICSharpCode.SharpZipLib.Zip;
using IronPdf;
class Program
{
static void Main()
{
string zipFilePath = "example.zip";
string extractPath = "ExtractedFiles";
// Extract files from ZIP
ExtractZip(zipFilePath, extractPath);
// Generate a PDF with the list of extracted files
var files = Directory.GetFiles(extractPath);
string htmlContent = "<h1>Extracted Files</h1><ul>" +
string.Join("", files.Select(file => $"<li>{Path.GetFileName(file)}</li>")) +
"</ul>";
var renderer = new ChromePdfRenderer();
var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
pdfDocument.SaveAs("ExtractedFilesReport.pdf");
Console.WriteLine("ZIP extracted and PDF generated successfully!");
}
static void ExtractZip(string zipFilePath, string extractPath)
{
if (!Directory.Exists(extractPath))
{
Directory.CreateDirectory(extractPath);
}
using (FileStream fs = File.OpenRead(zipFilePath))
using (ZipInputStream zipStream = new ZipInputStream(fs))
{
ZipEntry entry;
while ((entry = zipStream.GetNextEntry()) != null)
{
string filePath = Path.Combine(extractPath, entry.Name);
using (FileStream fileStream = File.Create(filePath))
{
zipStream.CopyTo(fileStream);
}
}
}
}
}
Sharpziplib Extraire ZIP C# (Comment ça marche pour les développeurs)
Regan Pun
juin 6, 2024
Partager:
Dans le paysage numérique actuel, où la gestion des données est primordiale, il est essentiel de disposer d'outils efficaces de compression et de décompression. L'un de ces outils qui se distingue dans l'écosystème .NET estSharpZipLib. Dans cet article, nous allons nous pencher sur SharpZipLib, en explorant ses caractéristiques, ses applications et la manière de l'intégrer dans vos projets .NET.
Qu'est-ce que SharpZipLib ?
SharpZipLib est une bibliothèque de compression riche en fonctionnalités et open-source pour .NET, entièrement écrite en C#. Il offre une prise en charge complète de divers formats de compression, notamment 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 efficacement les fichiers.
Caractéristiques et capacités
**SharpZipLib supporte les formats de compression populaires tels que ZIP, GZip, et Tar, répondant ainsi à divers cas d'utilisation et exigences.
Opérations basées sur les flux: La bibliothèque fonctionne sur les flux, ce qui permet aux développeurs de travailler avec des données provenant de diverses sources, notamment des fichiers, des flux de mémoire ou des flux de réseau. Cette flexibilité facilite l'intégration transparente dans les différentes parties d'une application.
Niveaux de compression: Les développeurs peuvent ajuster les niveaux de compression pour trouver un équilibre entre le taux de compression et la vitesse de traitement, en fonction de leurs besoins spécifiques.
Protection par mot de passe: SharpZipLib permet la création d'archives ZIP protégées par mot de passe, assurant la sécurité des données en cryptant le contenu avec un mot de passe spécifié.
Gestion des erreurs et récupération: Des mécanismes robustes de gestion des erreurs permettent aux développeurs de gérer les exceptions de manière élégante pendant les opérations de compression et de décompression. En outre, SharpZipLib prend en charge la récupération d'archives corrompues, ce qui améliore la fiabilité.
Cas d'utilisation
Compression et archivage de fichiers: SharpZipLib est idéal pour les applications qui nécessitent la compression et l'archivage de fichiers, comme les utilitaires de sauvegarde, les outils de gestion de fichiers ou les fonctionnalités d'exportation de données.
Services web et API: Les services web traitant de transferts de fichiers ou d'é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é de manière transparente dans de tels services pour compresser les données sortantes ou décompresser les charges utiles entrantes de manière efficace.
Applications de bureau: Les applications de bureau traitant de grands ensembles de données ou de fichiers de ressources peuvent utiliser SharpZipLib pour compresser les fichiers pour le stockage ou la distribution. Ceci est particulièrement utile pour les installateurs de logiciels ou les outils de synchronisation de données.
Sauvegarde et stockage de données: Les applications nécessitant des sauvegardes périodiques ou le stockage de données dans un format compressé peuvent automatiser le processus de sauvegarde et conserver l'espace de stockage de manière efficace en utilisant SharpZipLib.
Avantages de SharpZipLib
**En tant que bibliothèque open-source, SharpZipLib encourage la collaboration et les contributions de la communauté, assurant ainsi une amélioration continue et une adaptabilité à l'évolution des besoins.
Compatibilité multiplateforme: SharpZipLib, étant écrit en C# et ciblant le framework .NET, est compatible avec diverses plateformes, notamment Windows, Linux et macOS, ce qui renforce sa polyvalence.
**SharpZipLib est conçu pour être léger et efficace, minimisant la consommation de ressources tout en offrant des capacités de compression et de décompression de haute performance.
Documentation et support étendus: La documentation complète et le support de la communauté facilitent l'intégration et la résolution des problèmes lors de l'utilisation de SharpZipLib.
Créer un projet C# Visual Studio
Ouvrez Visual Studio et cliquez sur l'option "Créer un nouveau projet".
Choisissez le modèle de projet approprié en fonction de vos besoins(par exemple, application console, application Windows Forms).
Spécifiez le nom et l'emplacement du projet, puis cliquez sur "Suivant".
Dans la rubrique Informations complémentaires, sélectionnez le dernier Framework .NET. Cliquez sur "Créer" pour créer le projet.
Processus d'installation
Pour intégrer SharpZipLib dans votre projet .NET :
Dans votreL'IDE Visual Studio C# ConsoleApp, faites un clic droit sur votre projet dans l'explorateur de solutions et sélectionnez "Manage NuGet Packages..."
Dans la fenêtre du gestionnaire de paquets NuGet, recherchez "SharpZipLib".
Sélectionnez "SharpZipLib" dans les résultats de la recherche et cliquez sur le bouton "Installer".
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";
string zipFilePath = @"C:\OutputDirectory\compressed.zip";
// Compress files
CompressDirectory(sourceDirectory, zipFilePath);
Console.WriteLine("Files compressed successfully.");
string extractPath = @"C:\OutputDirectory\extracted";
// Decompress files
Decompress(zipFilePath, extractPath);
Console.WriteLine("Files decompressed successfully.");
}
static void CompressDirectory(string sourceDirectory, string zipFilePath)
{
using (var zipOutputStream = new ZipOutputStream(File.Create(zipFilePath)))
{
zipOutputStream.SetLevel(5); // Compression level (0-9)
// Recursively add files in the source directory to the ZIP file
AddDirectoryFilesToZip(sourceDirectory, zipOutputStream);
zipOutputStream.Finish();
zipOutputStream.Close();
}
}
static void AddDirectoryFilesToZip(string sourceDirectory, ZipOutputStream zipOutputStream)
{
string[] files = Directory.GetFiles(sourceDirectory);
foreach (string file in files)
{
var entry = new ZipEntry(Path.GetFileName(file));
zipOutputStream.PutNextEntry(entry);
using (var fileStream = File.OpenRead(file))
{
byte[] buffer = new byte[4096];
int sourceBytes;
while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
{
zipOutputStream.Write(buffer, 0, sourceBytes);
}
}
}
string[] subdirectories = Directory.GetDirectories(sourceDirectory);
foreach (string subdirectory in subdirectories)
{
AddDirectoryFilesToZip(subdirectory, zipOutputStream);
}
}
static void Decompress(string zipFilePath, string extractPath)
{
using (var zipInputStream = new ZipInputStream(File.OpenRead(zipFilePath)))
{
ZipEntry entry;
while ((entry = zipInputStream.GetNextEntry()) != null)
{
string entryPath = Path.Combine(extractPath, entry.Name);
if (entry.IsFile)
{
string directoryName = Path.GetDirectoryName(entryPath);
if (!Directory.Exists(directoryName))
Directory.CreateDirectory(directoryName);
using (var fileStream = File.Create(entryPath))
{
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
{
fileStream.Write(buffer, 0, bytesRead);
}
}
}
else if (entry.IsDirectory)
{
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";
string zipFilePath = @"C:\OutputDirectory\compressed.zip";
// Compress files
CompressDirectory(sourceDirectory, zipFilePath);
Console.WriteLine("Files compressed successfully.");
string extractPath = @"C:\OutputDirectory\extracted";
// Decompress files
Decompress(zipFilePath, extractPath);
Console.WriteLine("Files decompressed successfully.");
}
static void CompressDirectory(string sourceDirectory, string zipFilePath)
{
using (var zipOutputStream = new ZipOutputStream(File.Create(zipFilePath)))
{
zipOutputStream.SetLevel(5); // Compression level (0-9)
// Recursively add files in the source directory to the ZIP file
AddDirectoryFilesToZip(sourceDirectory, zipOutputStream);
zipOutputStream.Finish();
zipOutputStream.Close();
}
}
static void AddDirectoryFilesToZip(string sourceDirectory, ZipOutputStream zipOutputStream)
{
string[] files = Directory.GetFiles(sourceDirectory);
foreach (string file in files)
{
var entry = new ZipEntry(Path.GetFileName(file));
zipOutputStream.PutNextEntry(entry);
using (var fileStream = File.OpenRead(file))
{
byte[] buffer = new byte[4096];
int sourceBytes;
while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
{
zipOutputStream.Write(buffer, 0, sourceBytes);
}
}
}
string[] subdirectories = Directory.GetDirectories(sourceDirectory);
foreach (string subdirectory in subdirectories)
{
AddDirectoryFilesToZip(subdirectory, zipOutputStream);
}
}
static void Decompress(string zipFilePath, string extractPath)
{
using (var zipInputStream = new ZipInputStream(File.OpenRead(zipFilePath)))
{
ZipEntry entry;
while ((entry = zipInputStream.GetNextEntry()) != null)
{
string entryPath = Path.Combine(extractPath, entry.Name);
if (entry.IsFile)
{
string directoryName = Path.GetDirectoryName(entryPath);
if (!Directory.Exists(directoryName))
Directory.CreateDirectory(directoryName);
using (var fileStream = File.Create(entryPath))
{
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
{
fileStream.Write(buffer, 0, bytesRead);
}
}
}
else if (entry.IsDirectory)
{
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"
Dim zipFilePath As String = "C:\OutputDirectory\compressed.zip"
' Compress files
CompressDirectory(sourceDirectory, zipFilePath)
Console.WriteLine("Files compressed successfully.")
Dim extractPath As String = "C:\OutputDirectory\extracted"
' Decompress files
Decompress(zipFilePath, extractPath)
Console.WriteLine("Files decompressed successfully.")
End Sub
Private Shared Sub CompressDirectory(ByVal sourceDirectory As String, ByVal zipFilePath As String)
Using zipOutputStream As New ZipOutputStream(File.Create(zipFilePath))
zipOutputStream.SetLevel(5) ' Compression level (0-9)
' Recursively add files in the source directory to the ZIP file
AddDirectoryFilesToZip(sourceDirectory, zipOutputStream)
zipOutputStream.Finish()
zipOutputStream.Close()
End Using
End Sub
Private Shared Sub AddDirectoryFilesToZip(ByVal sourceDirectory As String, ByVal zipOutputStream As ZipOutputStream)
Dim files() As String = Directory.GetFiles(sourceDirectory)
For Each file As String In files
Dim entry = New ZipEntry(Path.GetFileName(file))
zipOutputStream.PutNextEntry(entry)
Using fileStream = System.IO.File.OpenRead(file)
Dim buffer(4095) As Byte
Dim sourceBytes As Integer
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
Dim subdirectories() As String = Directory.GetDirectories(sourceDirectory)
For Each subdirectory As String In subdirectories
AddDirectoryFilesToZip(subdirectory, zipOutputStream)
Next subdirectory
End Sub
Private Shared Sub Decompress(ByVal zipFilePath As String, ByVal extractPath As String)
Using zipInputStream As New ZipInputStream(File.OpenRead(zipFilePath))
Dim entry As ZipEntry
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)
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)
Dim buffer(4095) As Byte
Dim bytesRead As Integer
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
Directory.CreateDirectory(entryPath)
End If
entry = zipInputStream.GetNextEntry()
Loop
End Using
End Sub
End Class
End Namespace
$vbLabelText $csharpLabel
SharpZipLib est depuis longtemps un élément essentiel de 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 limites de SharpZipLib sont devenues évidentes.
Limites de SharpZipLib
Complexité : L'API de SharpZipLib peut être lourde et verbeuse, obligeant les développeurs à écrire un long code pour effectuer des tâches simples telles que la création ou l'extraction d'archives ZIP.
Manque de fonctionnalités modernes : SharpZipLib ne prend pas en charge les fonctionnalités et les plates-formes .NET modernes, ce qui le rend moins adapté aux environnements de développement contemporains.
Documentation limitée : Bien que SharpZipLib existe depuis longtemps, sa documentation est souvent peu abondante et obsolète, ce qui rend difficile pour les développeurs de démarrer ou de résoudre des problèmes.
Performances : Les performances de SharpZipLib ne répondent pas toujours aux attentes des développeurs, en particulier lorsqu'il s'agit d'archives volumineuses ou complexes.
IronZIP : combler le fossé
Documentation IronZIPdéveloppé parPrésentation du logiciel Iron Softwareest une solution moderne et efficace pour gérer les archives ZIP dans les applications .NET. Grâce à son API intuitive, les développeurs peuvent facilement créer, lire et manipuler des fichiers ZIP. IronZIP offre des fonctionnalités avancées telles que des niveaux de compression personnalisables et une protection par mot de passe, garantissant ainsi la flexibilité et la sécurité des données. Compatible avec les dernières versions .NET et optimisé pour les performances, IronZIP rationalise les tâches de gestion des archives avec facilité et efficacité.
Caractéristiques d'IronZIP apparaît comme une solution robuste et moderne qui répond aux lacunes de SharpZipLib. Voici comment IronZIP comble ces lacunes :
API avancée : IronZIP propose 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 avec seulement quelques lignes de code, réduisant ainsi le temps et les efforts de développement.
Compatibilité totale avec .NET : IronZIP prend entièrement en charge les dernières versions de .NET, notamment .NET Core, .NET Standard et .NET Framework, ce qui garantit la compatibilité avec les environnements de développement et les plateformes modernes.
Documentation complète : IronZIP est accompagné d'une documentation complète et d'exemples qui permettent aux développeurs de comprendre rapidement ses caractéristiques et ses capacités. La documentation complète aide à simplifier la courbe d'apprentissage et facilite l'intégration rapide dans les projets.
Contrôle du niveau de compression : IronZIP offre aux développeurs un contrôle sur le niveau de compression, ce qui leur permet d'ajuster le niveau de compression en fonction de leurs besoins. Cette fonction permet aux développeurs de trouver un équilibre entre la réduction de la taille des fichiers et la vitesse de compression.
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 ainsi que seuls les utilisateurs autorisés peuvent accéder au contenu de l'archive.
Optimisation des performances : IronZIP est optimisé pour la performance, offrant des vitesses de compression et d'extraction plus rapides par rapport à SharpZipLib. Cette optimisation permet aux développeurs de traiter efficacement de grands volumes de données sans compromettre les performances.
Dans le menu Outils, accédez à la console NuGet Package Manager.
Exécutez la commande suivante pour installer le paquetage IronZIP :
Install-Package IronZip
Vous pouvez également l'installer à partir de NuGet Package Manager for Solutions.
Sélectionnez IronZIP dans l'onglet de navigation de NuGet et cliquez sur installer :
Exemple de code
Le code source suivant montre comment IronZIP fonctionne efficacementcrée un fichier ZIP avec IronZIP avec facilité et en quelques lignes de code seulement. Ici, vous pouvez ajouter plusieurs fichiers auarchive 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 afin de 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
$vbLabelText $csharpLabel
Fichier Zip de sortie
Conclusion
Vue d'ensemble de SharpZipLib s'impose comme une puissante bibliothèque de compression pour .NET, offrant un riche ensemble de fonctionnalités et de capacités pour traiter efficacement les fichiers compressés. Qu'il s'agisse de compresser des données pour le stockage, d'archiver des fichiers ou d'optimiser l'utilisation de la bande passante dans les services web, SharpZipLib fournit les outils nécessaires pour rationaliser les opérations de compression et de décompression. Grâce à sa nature open-source, sa compatibilité multiplateforme et ses fonctionnalités robustes, 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 limites sont devenues de plus en plus évidentes dans le paysage actuel du développement. Explorer l'API IronZIP vient combler les lacunes laissées par SharpZipLib, en offrant une alternative moderne et riche en fonctionnalités qui privilégie la facilité d'utilisation, les performances et la compatibilité. Avec IronZIP, les développeurs peuvent exploiter de nouvelles possibilités en matière de gestion d'archives et rationaliser leur flux de développement grâce à des fonctionnalités avancées et à une API intuitive.
Regan est diplômé de l'université de Reading, où il a obtenu une licence en ingénierie électronique. Avant de rejoindre Iron Software, il s'était concentré sur une seule tâche. Ce qu'il apprécie le plus chez Iron Software, c'est la diversité des tâches qu'il peut accomplir, qu'il s'agisse d'apporter une valeur ajoutée aux ventes, à l'assistance technique, au développement de produits ou à la commercialisation. Il aime comprendre comment les développeurs utilisent la bibliothèque d'Iron Software et utiliser ces connaissances pour améliorer continuellement la documentation et développer les produits.
< PRÉCÉDENT Xceed.Document .NET (Comment ça marche pour les développeurs)
SUIVANT > Xdocument C# (Comment ça marche pour les développeurs)
Des millions d'ingénieurs dans le monde entier lui font confiance
Réservez une démo en direct gratuite
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
Voici ce à quoi vous pouvez vous attendre :
Une démonstration en direct de notre produit et de ses principales fonctionnalités
Obtenez des recommandations de fonctionnalités spécifiques au projet
Toutes vos questions trouvent réponse pour vous assurer de disposer de toutes les informations dont vous avez besoin. (Aucun engagement de votre part.)
CHOISIR L'HEURE
VOS INFORMATIONS
Réservez votre démo en direct gratuite
Fiable par plus de 2 millions d'ingénieurs dans le monde entier