Fr

KNOWLEDGEBASE

Compressez ou décompressez des fichiers à l'aide de C# - Compression et décompression de fichiers

Qu’est-ce que ZIP (format de fichier)

ZIP est un format de fichier d’archive qui prend en charge la compression de données sans perte. Un fichier ZIP peut contenir un ou plusieurs fichiers ou répertoires qui peuvent avoir été compressés. Les fichiers ZIP utilisent généralement les extensions de fichier .zip ou .ZIP et le type de média MIME application/zip. ZIP est utilisé comme format de fichier de base par de nombreux programmes, généralement sous un nom différent. Lors de la navigation dans un système de fichiers via une interface utilisateur, les icônes graphiques représentant les fichiers ZIP apparaissent souvent sous la forme d’un document ou d’un autre objet mettant en évidence une fermeture éclair. Il existe plusieurs façons de compresser des fichiers, cela dépend du système d’exploitation que vous utilisez. Et presque tous les jours, nous sommes censés compresser ou décompresser certains fichiers et les transférer vers un serveur de stockage ou une plate-forme de partage de fichiers. Heureusement, nous pouvons automatiser ce processus en utilisant Aspose.ZIP API. Il vous permet de compresser et de décompresser des fichiers sans vous soucier de la structure de fichiers sous-jacente. Cet article montre comment travailler avec une compression de fichiers unique et multiple. Le package Aspose.ZIP peut être ajouté à votre projet .NET à l’aide de la commande NuGet suivante :

PM> Install-Package Aspose.Zip

Comment compresser un seul fichier avec C#

  1. Nous devons d’abord créer un objet de [classe FileStream] ( https://learn.microsoft.com/en-us/dotnet/api/system.io.filestream?view=net-7.0) pour l’archive ZIP de sortie
  2. Chargez un seul fichier dans l’objet FileStream
  3. Créez un objet de la Classe d’archive
  4. Ajoutez le fichier dans l’archive à l’aide de la méthode Archive.CreateEntry( “FileName”, FileStream).
  5. Créez l’archive ZIP à l’aide de la méthode Archive.Save(FileStream).
        using (FileStream zipFile = File.Open(dataDir + "CompressSingleFile_out.zip", FileMode.Create))
        {
            //File to be added to archive
            using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
            {
                    using (var archive = new Archive(new ArchiveEntrySettings()))
                {
                    archive.CreateEntry("alice29.txt", source1);
                    archive.Save(zipFile);
                }
            }
        }

Compresser plusieurs fichiers avec C#

La différence entre la compression d’un seul fichier et de plusieurs fichiers est que nous devons charger plus de fichiers dans le FileStream et les ajouter tous à l’archive ZIP en utilisant la méthode Archive.CreateEntry(“FileName”, FileStream) L’extrait de code suivant montre comment ajouter plusieurs fichiers dans le ZIP à l’aide de FileStream.

        // Create FileStream for output ZIP archive
        using (FileStream zipFile = File.Open("compressed_files.zip", FileMode.Create))
        {
	        // File to be added to archive
	        using (FileStream source1 = File.Open("alice29.txt", FileMode.Open, FileAccess.Read))
	            {
		            // File to be added to archive
		            using (FileStream source2 = File.Open("asyoulike.txt", FileMode.Open, FileAccess.Read))
		        {
			        using (var archive = new Archive())
			            {
				            // Add files to the archive
				            archive.CreateEntry("alice29.txt", source1);
				            archive.CreateEntry("asyoulik3.txt", source2);
				            // ZIP the files
				            archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII, ArchiveComment = "two files are compressed in this archive" });
		            	}
		        }
	        }
        }

Compresser les fichiers à l’aide de la classe FileInfo

Les fichiers peuvent également être chargés à l’aide de la classe FileInfo et ajoutés ultérieurement à l’archive ZIP de la même manière qu’auparavant. La classe FileInfo fournit des propriétés et des méthodes d’instance pour la création, la copie, la suppression, le déplacement et l’ouverture de fichiers, et aide à la création d’objets FileStream.

    using (FileStream zipFile = File.Open("compressed_files.zip", FileMode.Create))
    {
	    // Files to be added to archive
	    FileInfo fi1 = new FileInfo("alice29.txt");
	    FileInfo fi2 = new FileInfo("fields.c");
	    using (var archive = new Archive())
	        {
		        // Add files to the archive
		        archive.CreateEntry("alice29.txt", fi1);
		        archive.CreateEntry("fields.c", fi2);
		        // Create ZIP archive
		        archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
	        }
    }

Stockage de fichiers dans des archives sans compression

    //Creates zip archive without compressing files
    using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Create))
    {
    FileInfo fi1 = new FileInfo(dataDir + "alice29.txt");
    FileInfo fi2 = new FileInfo(dataDir + "lcet10.txt");

    using (Archive archive = new Archive(new ArchiveEntrySettings(new StoreCompressionSettings())))
    {
        archive.CreateEntry("alice29.txt", fi1);
        archive.CreateEntry("lcet10.txt", fi2);
        archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
    }
    }

Comment compresser des fichiers avec un mot de passe en C#

    using (var archive = new Archive(new ArchiveEntrySettings(encryptionSettings: new TraditionalEncryptionSettings("pass"))))
    {
    archive.CreateEntry("entry_name1.dat", "input_file1.dat");
    archive.CreateEntry("entry_name2.dat", "input_file2.dat");
    archive.Save("result_archive.zip");
    }

Le paramètre encryptionSettings est utilisé pour créer une archive ZIP protégée par un mot de passe.

Comment décompresser des fichiers avec un mot de passe en C#

    using (var archive = new Archive("input_archive.zip", new ArchiveLoadOptions{DecryptionPassword = "pass"}))
    {
    archive.ExtractToDirectory("\\outputDirectory");
    }

La valeur de la propriété ArchiveLoadOptions with DecryptionPassword est utilisée pour ouvrir une archive ZIP protégée par un mot de passe. Pour voir des exemples complets et des fichiers de données, rendez-vous sur https://github.com/aspose-zip/Aspose.ZIP-for-.NET.

Utilisation de la compression LZMA dans l’archive ZIP

L’algorithme de chaîne Lempel – Ziv – Markov (LZMA) est un algorithme utilisé pour effectuer une compression de données sans perte. LZMA utilise un algorithme de compression de dictionnaire, le flux compressé est un flux de bits. La compression LZMA dans l’archive ZIP permet aux conteneurs ZIP de contenir des entrées compressées LZMA. L’exemple de code suivant montre l’implémentation de la compression LZMA à l’aide de l’ API Aspose.ZIP.

using (FileStream zipFile = File.Open(dataDir + "LZMACompression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new LzmaCompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Utilisation de la compression BZip2 dans l’archive ZIP

bzip2 est un programme de compression de fichiers gratuit et open-source qui utilise l’algorithme Burrows-Wheeler. Il ne compresse que des fichiers uniques et n’est pas un archiveur de fichiers. Il a été développé par Julian Seward et maintenu par Mark Wielaard et Micah Snyder. L’extrait de code suivant montre l’implémentation de la compression BZip2 à l’aide de l’ API Aspose.ZIP.

using (FileStream zipFile = File.Open(dataDir + "Bzip2Compression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new Bzip2CompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Utilisation de la compression PPMd dans l’archive ZIP

La prédiction par appariement partiel (PPM) est une technique de compression de données statistiques adaptative basée sur la modélisation et la prédiction du contexte. Les modèles PPM utilisent un ensemble de symboles précédents dans le flux de symboles non compressé pour prédire le symbole suivant dans le flux. Les algorithmes PPM peuvent également être utilisés pour regrouper les données en groupes prédits dans l’analyse de cluster. L’extrait de code suivant montre l’implémentation de la compression PPMd à l’aide de l’ API Aspose.ZIP.

using (FileStream zipFile = File.Open(dataDir + "PPMdCompression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new PPMdCompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Décompresser l’archive avec un seul fichier

using (FileStream fs = File.OpenRead(dataDir + "CompressSingleFile_out.zip"))
{
    using (Archive archive = new Archive(fs))
    {
        int percentReady = 0;
        archive.Entries[0].ExtractionProgressed += (s, e) =>
        {
            int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
            if (percent > percentReady)
            {
                Console.WriteLine(string.Format("{0}% decompressed", percent));
                percentReady = percent;
            }
        };
        archive.Entries[0].Extract(dataDir + "alice_extracted_out.txt");
    }
}

Décompresser l’archive avec plusieurs fichiers

using (FileStream fs = File.OpenRead(dataDir + "CompressSingleFile_out.zip"))
{
    using (Archive archive = new Archive(fs))
    {
        int percentReady = 0;
        archive.Entries[0].ExtractionProgressed += (s, e) =>
        {
            int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
            if (percent > percentReady)
            {
                Console.WriteLine(string.Format("{0}% decompressed", percent));
                percentReady = percent;
            }
        };
        archive.Entries[0].Extract(dataDir + "alice_extracted_out.txt");
    }
}

Decompress Archive with Multiple Files

using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Open))
{
    StringBuilder sb = new StringBuilder("Entries are: ");
    int percentReady = 0;
    using (Archive archive = new Archive(zipFile,
        new ArchiveLoadOptions()
        {
            EntryListed = (s, e) => { sb.AppendFormat("{0}, ", e.Entry.Name); },
            EntryExtractionProgressed = (s, e) =>
            {
                int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
                if (percent > percentReady)
                {
                    Console.WriteLine(string.Format("{0}% compressed", percent)); percentReady = percent;
                }
            }
        }))
    {
        Console.WriteLine(sb.ToString(0, sb.Length - 2));
        using (var extracted = File.Create(dataDir + "alice_extracted_out.txt"))
        {
            using (var decompressed = archive.Entries[0].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }
        percentReady = 0;
        archive.Entries[1].Extract(dataDir + "asyoulik_extracted_out.txt");
    }
}

Extraire l’archive stockée sans compression

using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Open))
{
    using (Archive archive = new Archive(zipFile))
    {
        using (var extracted = File.Create(dataDir + "alice_extracted_store_out.txt"))
        {
            using (var decompressed = archive.Entries[0].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }

        using (var extracted = File.Create(dataDir + "asyoulik_extracted_store_out.txt"))
        {
            using (var decompressed = archive.Entries[1].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }
    }
}

Pour des exemples complets et des fichiers de données, rendez-vous sur https://github.com/aspose-zip/Aspose.ZIP-for-.NET