Zip eller unzip-filer med C# - Filkomprimering och dekomprimering

Vad är ZIP (filformat)

ZIP är ett arkivfilformat som stödjer förlustfri datakomprimering. En ZIP‑fil kan innehålla en eller flera filer eller kataloger som har komprimerats. ZIP‑filer använder vanligtvis filändelserna .zip eller .ZIP och MIME‑typen application/zip. Många program använder ZIP som grundformat, ofta under ett annat namn. När du navigerar i ett filsystem via ett grafiskt gränssnitt visas ikoner för ZIP‑filer ofta som ett dokument eller ett annat objekt med en tydlig dragkedja.

Det finns flera sätt att zipa (komprimera) filer , beroende på vilket operativsystem du använder. Och nästan varje dag måste vi zipa eller unzippa filer och skicka dem till en lagringsserver eller en fildelningsplattform. Lyckligtvis kan vi automatisera processen med hjälp av Aspose.ZIP API . Det låter dig komprimera och dekomprimera filer utan att oroa dig för den underliggande filstrukturen. Denna artikel visar hur du arbetar med både enskild och flera filers komprimering.

Aspose.ZIP‑paketet kan läggas till i ditt .NET‑projekt med följande NuGet‑kommando:

PM> Install-Package Aspose.Zip

Så komprimerar du en enskild fil med C#

Först måste vi skapa ett objekt av FileStream‑klassen för utdata‑ZIP‑arkivet.
Läs in en enskild fil i FileStream -objektet.
Skapa ett objekt av Archive‑klassen .
Lägg till filen i arkivet med metoden Archive.CreateEntry ( “FileName”, FileStream ).
Skapa ZIP‑arkivet med metoden 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);
        }
    }
}

Komprimerar flera filer med C#

Skillnaden mellan att komprimera en enskild fil och flera filer är att vi måste läsa in fler filer i FileStream och lägga till dem alla i ZIP‑arkivet med metoden Archive.CreateEntry("FileName", FileStream).

Följande kodexempel visar hur du lägger till flera filer i ZIP‑arkivet med 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" });
            }
        }
    }
}

Komprimera filer med FileInfo‑klass

Filer kan också läsas in med FileInfo‑klassen och sedan läggas till i ZIP‑arkivet på samma sätt som tidigare.
FileInfo‑klassen tillhandahåller egenskaper och instansmetoder för att skapa, kopiera, radera, flytta och öppna filer samt underlättar skapandet av FileStream‑objekt.

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

Lagra filer i arkiv utan komprimering

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

Så zippar du filer med lösenord i 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");
}

encryptionSettings‑parametern används för att skapa ett lösenordsskyddat ZIP‑arkiv.

Så unzippar du filer med lösenord i C#

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

ArchiveLoadOptions med egenskapen DecryptionPassword används för att öppna ett lösenordsskyddat ZIP‑arkiv.
För att se kompletta exempel och datafiler, besök gärna GitHub‑förrådet .

Användning av LZMA-komprimering i ZIP‑arkiv

Lempel–Ziv–Markov‑kedjealgoritmen (LZMA) är en algoritm för förlustfri datakomprimering. LZMA använder en ordboksbaserad komprimeringsmetod där den komprimerade strömmen består av bitar. LZMA‑komprimering i ett ZIP‑arkiv möjliggör att ZIP‑behållare kan innehålla LZMA‑komprimerade poster. Följande kodexempel visar hur LZMA‑komprimering implementeras med 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);
    }
}

Användning av BZip2-komprimering i ZIP‑arkiv

bzip2 är ett fritt och öppet filkomprimeringsprogram som använder Burrows–Wheeler‑algoritmen. Det komprimerar endast enskilda filer och är inte ett arkiveringsverktyg. Det utvecklades av Julian Seward och underhålls av Mark Wielaard och Micah Snyder. Följande kodsnutt visar hur BZip2‑komprimering implementeras med 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);
    }
}

Användning av PPMd-komprimering i ZIP‑arkiv

Prediction by Partial Matching (PPM) är en adaptiv statistisk datakomprimeringsteknik baserad på kontextmodellering och förutsägelse. PPM‑modeller använder en uppsättning tidigare symboler i den okomprimerade symbolströmmen för att förutsäga nästa symbol. PPM‑algoritmer kan även användas för att gruppera data i förutsagda kluster i klusteranalys. Följande kodsnutt visar hur PPMd‑komprimering implementeras med 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);
    }
}

Dekomprimera arkiv med en enda fil

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

Dekomprimera arkiv med flera filer

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

Extrahera lagrat arkiv utan komprimering

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

För kompletta exempel och datafiler, besök gärna GitHub‑förrådet .