Komprimace a dekomprimace souborů pomocí C# - Zipování a rozbalování souborů

Co je ZIP (formát souboru)

ZIP je archivní formát souboru, který podporuje bezztrátovou kompresi dat. ZIP soubor může obsahovat jeden nebo více souborů či adresářů, které byly komprimovány. ZIP soubory obvykle používají přípony .zip nebo .ZIP a MIME typ application/zip. ZIP slouží jako základní formát pro mnoho programů, často pod jiným názvem. Při procházení souborového systému v uživatelském rozhraní se ikony představující ZIP soubory často zobrazují jako dokument nebo jiný objekt s výrazným motivem zipky.
Existuje více způsobů, jak zipovat (komprimovat) soubory , v závislosti na operačním systému. Téměř každý den potřebujeme soubory zipovat nebo rozbalovat a následně je odeslat na úložiště nebo platformu pro sdílení souborů. Naštěstí můžeme tento proces automatizovat pomocí Aspose.ZIP API . Umožňuje komprimovat a dekomprimovat soubory bez starostí o podkladovou strukturu souborů. Tento článek ukazuje práci s kompresí jednoho i více souborů.
Balíček Aspose.ZIP lze přidat do vašeho .NET projektu pomocí následujícího NuGet příkazu:

PM> Install-Package Aspose.Zip

Jak komprimovat jeden soubor pomocí C#

Nejprve vytvoříme objekt třídy FileStream pro výstupní ZIP archiv.
Načteme jeden soubor do objektu FileStream.
Vytvoříme objekt třídy Archive.
Přidáme soubor do archivu pomocí metody Archive.CreateEntry („FileName“, FileStream).
Vytvoříme ZIP archiv pomocí metody 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);
        }
    }
}

Komprese více souborů pomocí C#

Rozdíl mezi kompresí jednoho a více souborů spočívá v tom, že musíme načíst více souborů do FileStream a všechny je přidat do ZIP archivu pomocí metody Archive.CreateEntry(“FileName”, FileStream).
Následující úryvek kódu ukazuje, jak přidat více souborů do ZIP pomocí 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" });
            }
        }
    }
}

Komprese souborů pomocí třídy FileInfo

Soubory lze také načíst pomocí třídy FileInfo a následně je přidat do ZIP archivu stejným způsobem jako dříve.
Třída FileInfo poskytuje vlastnosti a instance metody pro vytváření, kopírování, mazání, přesouvání a otevírání souborů a usnadňuje tvorbu objektů 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 });
    }
}

Ukládání souborů do archivu bez komprese

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

Jak vytvořit ZIP soubor s heslem v 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");
}

Parametr encryptionSettings slouží k vytvoření ZIP archivu chráněného heslem.

Jak rozbalit ZIP soubor s heslem v C#

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

Třída ArchiveLoadOptions s nastavením DecryptionPassword se používá k otevření ZIP archivu chráněného heslem.
Pro kompletní příklady a datové soubory navštivte https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

Použití LZMA komprese v ZIP archivu

Algoritmus Lempel–Ziv–Markov chain (LZMA) je určen pro bezztrátovou kompresi dat. LZMA používá kompresi slovníku; komprimovaný tok je posloupnost bitů. LZMA komprese v ZIP archivu umožňuje, aby kontejnery ZIP obsahovaly LZMA‑komprimované položky. Následující ukázka kódu demonstruje implementaci LZMA komprese pomocí 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);
    }
}

Použití BZip2 komprese v ZIP archivu

bzip2 je volně dostupný a otevřený program pro kompresi souborů, který využívá algoritmus Burrows–Wheeler. Komprimuje pouze jednotlivé soubory a není archivátorem. Byl vyvinut Juliánem Sewardem a udržován Markem Wielaardem a Micahem Snyderem. Následující úryvek kódu ukazuje implementaci BZip2 komprese pomocí 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);
    }
}

Použití PPMd komprese v ZIP archivu

Prediction by Partial Matching (PPM) je adaptivní statistická technika komprese dat založená na modelování kontextu a predikci. Modely PPM používají sadu předchozích symbolů v nekomprimovaném proudu k předpovědi dalšího symbolu. Algoritmy PPM lze také využít ke shlukování dat do předpovězených skupin při analýze shluků. Následující úryvek kódu ukazuje implementaci PPMd komprese pomocí 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);
    }
}

Dekompresie archivu s jedním souborem

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

Dekompresie archivu s více soubory

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

Extrahování archivů uložených bez komprese

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

Pro kompletní příklady a datové soubory navštivte https://github.com/aspose-zip/Aspose.ZIP-for-.NET .