Zip of unzip bestanden met C# - Bestanden compressie en decompressie

Wat is ZIP (bestandsformaat)

ZIP is een archiefbestandformaat dat verliesloze gegevenscompressie ondersteunt. Een ZIP‑bestand kan één of meerdere bestanden of mappen bevatten die gecomprimeerd zijn. ZIP‑bestanden gebruiken doorgaans de bestandsextensies .zip of .ZIP en het MIME‑type application/zip. Veel programma’s gebruiken ZIP als basisformaat, vaak onder een andere naam. Wanneer u een bestandssysteem via een gebruikersinterface verkent, verschijnen grafische pictogrammen die ZIP‑bestanden voorstellen vaak als een document of een ander object met een opvallende rits.

Er zijn meerdere manieren om bestanden te zippen (comprimeren) , afhankelijk van het besturingssysteem dat u gebruikt. En bijna elke dag moeten we bestanden zippen of unzippen en ze naar een opslag‑ of bestandsdelingsserver sturen. Gelukkig kunnen we dat proces automatiseren met de Aspose.ZIP API . Hiermee kunt u bestanden comprimeren en decomprimeren zonder u zorgen te maken over de onderliggende bestandstructuur. Dit artikel laat zien hoe u zowel enkel‑ als meervoudige bestandscompressie kunt uitvoeren.

Aspose.ZIP‑pakket kan aan uw .NET‑project worden toegevoegd met de volgende NuGet‑opdracht:

PM> Install-Package Aspose.Zip

Hoe een enkel bestand te comprimeren met C#

Maak eerst een object van de FileStream‑klasse voor het uitvoer‑ZIP‑archief.
Laad een enkel bestand in het FileStream‑object.
Maak een object van de Archive‑klasse.
Voeg het bestand toe aan het archief met de methode Archive.CreateEntry (“Bestandsnaam”, FileStream).
Sla het ZIP‑archief op met de methode Archive.Save (FileStream).

using (FileStream zipFile = File.Open(dataDir + "CompressSingleFile_out.zip", FileMode.Create))
{
    // Bestand dat aan het archief moet worden toegevoegd
    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);
        }
    }
}

Meerdere bestanden comprimeren met C#

Het verschil tussen het comprimeren van één bestand en meerdere bestanden is dat we meer bestanden moeten laden in de FileStream en ze allemaal moeten toevoegen aan het ZIP‑archief met de methode Archive.CreateEntry(“Bestandsnaam”, FileStream).

De volgende code‑fragment toont hoe u meerdere bestanden toevoegt aan een ZIP‑archief met FileStream.

// Maak FileStream voor het uitvoer‑ZIP‑archief
using (FileStream zipFile = File.Open("compressed_files.zip", FileMode.Create))
{
    // Eerste bestand dat aan het archief moet worden toegevoegd
    using (FileStream source1 = File.Open("alice29.txt", FileMode.Open, FileAccess.Read))
    {
        // Tweede bestand dat aan het archief moet worden toegevoegd
        using (FileStream source2 = File.Open("asyoulike.txt", FileMode.Open, FileAccess.Read))
        {
            using (var archive = new Archive())
            {
                // Voeg bestanden toe aan het archief
                archive.CreateEntry("alice29.txt", source1);
                archive.CreateEntry("asyoulik3.txt", source2);
                // Zip de bestanden
                archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII, ArchiveComment = "twee bestanden zijn gecomprimeerd in dit archief" });
            }
        }
    }
}

Bestanden comprimeren met de FileInfo‑klasse

Bestanden kunnen ook worden geladen met de FileInfo‑klasse en vervolgens op dezelfde manier aan het ZIP‑archief worden toegevoegd als eerder.

De FileInfo‑klasse biedt eigenschappen en methoden voor het maken, kopiëren, verwijderen, verplaatsen en openen van bestanden, en helpt bij het aanmaken van FileStream‑objecten.

using (FileStream zipFile = File.Open("compressed_files.zip", FileMode.Create))
{
    // Bestanden die aan het archief moeten worden toegevoegd
    FileInfo fi1 = new FileInfo("alice29.txt");
    FileInfo fi2 = new FileInfo("fields.c");
    using (var archive = new Archive())
    {
        // Voeg bestanden toe aan het archief
        archive.CreateEntry("alice29.txt", fi1);
        archive.CreateEntry("fields.c", fi2);
        // Maak ZIP‑archief
        archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
    }
}

Bestanden opslaan in archieven zonder compressie

// Maakt een zip‑archief zonder bestanden te comprimeren
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 });
    }
}

ZIP‑bestanden beveiligen met een wachtwoord 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");
}

De encryptionSettings‑parameter wordt gebruikt om een wachtwoord‑beveiligd ZIP‑archief te maken.

ZIP‑bestanden met wachtwoord uitpakken in C#

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

De ArchiveLoadOptions‑eigenschap DecryptionPassword wordt gebruikt om een wachtwoord‑beveiligd ZIP‑archief te openen.

Voor volledige voorbeelden en data‑bestanden, ga naar https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

LZMA‑compressie gebruiken binnen een ZIP‑archief

Het Lempel–Ziv–Markov‑keten‑algoritme (LZMA) is een methode voor verliesloze gegevenscompressie. LZMA maakt gebruik van een woordenboek‑compressie‑algoritme; de gecomprimeerde stroom bestaat uit bits. LZMA‑compressie binnen een ZIP‑archief maakt het mogelijk om LZMA‑gecomprimeerde items in ZIP‑containers op te nemen. Het volgende voorbeeld toont de implementatie van LZMA‑compressie met de 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);
    }
}

BZip2‑compressie gebruiken binnen een ZIP‑archief

bzip2 is een gratis en open‑source bestandscompressieprogramma dat het Burrows–Wheeler‑algoritme gebruikt. Het comprimeert alleen losse bestanden en is geen archiveringsprogramma. Het is ontwikkeld door Julian Seward en wordt onderhouden door Mark Wielaard en Micah Snyder. Het volgende fragment toont de implementatie van BZip2‑compressie met de 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);
    }
}

PPMd‑compressie gebruiken binnen een ZIP‑archief

Prediction by Partial Matching (PPM) is een adaptieve statistische compressietechniek gebaseerd op contextmodellering en voorspelling. PPM‑modellen gebruiken een reeks eerdere symbolen in de ongecomprimeerde stroom om het volgende symbool te voorspellen. Het volgende fragment toont de implementatie van PPMd‑compressie met de 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);
    }
}

Archief decomprimeren met één bestand

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}% gedecomprimeerd", percent));
                percentReady = percent;
            }
        };
        archive.Entries[0].Extract(dataDir + "alice_extracted_out.txt");
    }
}

Archief decomprimeren met meerdere bestanden

using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Open))
{
    StringBuilder sb = new StringBuilder("Items zijn: ");
    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}% gecomprimeerd", 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);
                }
                // Lees van de gedecomprimeerde stream naar het doelbestand.
            }
        }
        percentReady = 0;
        archive.Entries[1].Extract(dataDir + "asyoulik_extracted_out.txt");
    }
}

Opslag‑archief zonder compressie uitpakken

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);
                }
                // Lees van de gedecomprimeerde stream naar het doelbestand.
            }
        }

        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);
                }
                // Lees van de gedecomprimeerde stream naar het doelbestand.
            }
        }
    }
}

Voor volledige voorbeelden en data‑bestanden, ga naar https://github.com/aspose-zip/Aspose.ZIP-for-.NET .