Comprimi o decomprimi file con C# - Compressione e decompressione di file

Cos’è ZIP (formato file)

ZIP è un formato di archivio che supporta la compressione senza perdita di dati. Un file ZIP può contenere uno o più file o directory che sono stati compressi. I file ZIP utilizzano generalmente le estensioni .zip o .ZIP e il tipo MIME application/zip. ZIP è usato come formato di base da molti programmi, spesso sotto un nome diverso. Quando si naviga un file system tramite un’interfaccia grafica, le icone che rappresentano i file ZIP appaiono spesso come un documento o un altro oggetto con un evidente simbolo di cerniera.

Ci sono diversi modi per comprimere (zippare) i file , a seconda del sistema operativo utilizzato. Quasi ogni giorno dobbiamo comprimere o decomprimere alcuni file e trasferirli a un server di archiviazione o a una piattaforma di condivisione file. Fortunatamente, possiamo automatizzare questo processo usando l’Aspose.ZIP API . Consente di comprimere e decomprimere file senza preoccuparsi della struttura sottostante. Questo articolo mostra come lavorare con la compressione di un singolo file e di più file.

Il pacchetto Aspose.ZIP può essere aggiunto al tuo progetto .NET con il seguente comando NuGet:

PM> Install-Package Aspose.Zip

Come comprimere un singolo file con C#

Prima dobbiamo creare un oggetto della classe FileStream class per l’archivio ZIP di output.
Caricare un singolo file nell’oggetto FileStream .
Creare un oggetto della classe Archive class .
Aggiungere il file all’archivio usando il metodo Archive.CreateEntry (“FileName”, FileStream).
Creare l’archivio ZIP usando il metodo 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);
                }
            }
        }

Comprimere più file con C#

La differenza tra comprimere un singolo file e più file è che dobbiamo caricare più file nel FileStream e aggiungerli tutti all’archivio ZIP usando il metodo Archive.CreateEntry("FileName", FileStream).

Il seguente frammento di codice mostra come aggiungere più file al ZIP usando 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" });
		            	}
		        }
	        }
        }

Comprimere file utilizzando la classe FileInfo

I file possono anche essere caricati usando la classe FileInfo e successivamente aggiunti all’archivio ZIP nello stesso modo mostrato in precedenza.
La classe FileInfo fornisce proprietà e metodi di istanza per la creazione, copia, eliminazione, spostamento e apertura dei file, e facilita la creazione di oggetti 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 });
	        }
    }

Archiviare file senza compressione

    //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 });
    }
    }

Come creare file ZIP con password in 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");
    }

Il parametro encryptionSettings è usato per creare un archivio ZIP protetto da password.

Come estrarre file ZIP con password in C#

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

L’opzione ArchiveLoadOptions con la proprietà DecryptionPassword è utilizzata per aprire un archivio ZIP protetto da password.

Per vedere esempi completi e file di dati, visita https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

Utilizzare la compressione LZMA all’interno di un archivio ZIP

L’algoritmo Lempel–Ziv–Markov chain (LZMA) è un algoritmo usato per eseguire la compressione senza perdita di dati. LZMA utilizza un algoritmo di compressione basato su dizionario; il flusso compresso è una sequenza di bit. La compressione LZMA all’interno di un archivio ZIP consente ai contenitori ZIP di contenere voci compresse con LZMA. Il seguente esempio di codice mostra l’implementazione della compressione LZMA usando l’Aspose.ZIP API .

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);
    }
}

Utilizzare la compressione BZip2 all’interno di un archivio ZIP

bzip2 è un programma di compressione file gratuito e open‑source che utilizza l’algoritmo di Burrows–Wheeler. Comprende solo file singoli e non è un archiviatore di file. È stato sviluppato da Julian Seward e mantenuto da Mark Wielaard e Micah Snyder. Il seguente frammento di codice mostra l’implementazione della compressione BZip2 usando l’Aspose.ZIP API .

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);
    }
}

Utilizzare la compressione PPMd all’interno di un archivio ZIP

La predizione per corrispondenza parziale (PPM) è una tecnica di compressione statistica adattiva basata sulla modellazione del contesto e sulla predizione. I modelli PPM usano un insieme di simboli precedenti nel flusso di simboli non compressi per prevedere il simbolo successivo. Gli algoritmi PPM possono anche essere usati per raggruppare dati in gruppi predetti nell’analisi dei cluster. Il seguente frammento di codice mostra l’implementazione della compressione PPMd usando l’Aspose.ZIP API .

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);
    }
}

Decomprimere un archivio con un singolo file

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");
    }
}

Decomprimere un archivio con più file

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");
    }
}

Estrarre un archivio archiviato senza compressione

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.
            }
        }
    }
}

Per esempi completi e file di dati, visita https://github.com/aspose-zip/Aspose.ZIP-for-.NET .