ZIP arba išskleisti failus naudojant C# – Failų suspaudimas ir išskleidimas

Kas yra ZIP (failų formatas)

ZIP yra archyvo failų formatas, palaikantis beprarastinį duomenų suspaudimą. ZIP failas gali turėti vieną ar kelis failus arba katalogus, kurie buvo suspausti. ZIP failai paprastai naudoja failų plėtinius .zip arba .ZIP ir MIME tipą application/zip. Dauguma programų naudoja ZIP kaip pagrindinį archyvo formatą, dažnai su kitokiu pavadinimu. Naršant failų sistemą per vartotojo sąsają, grafiniai ZIP failų piktogramos dažnai rodomos kaip dokumentas ar kitas objektas, kuriame ryškiai matomas užtrauktukas.

Yra kelios būdai suspausti (kompresuoti) failus , priklausomai nuo naudojamos operacinės sistemos. Beveik kasdien turime suspausti arba išskleisti failus ir persiųsti juos į saugojimo serverį ar failų dalijimosi platformą. Laimei, šį procesą galima automatizuoti naudojant Aspose.ZIP API . Ji leidžia suspausti ir išskleisti failus nesirūpinant pagrindine failų struktūra. Šiame straipsnyje pateikiami pavyzdžiai, kaip dirbti tiek su vieno, tiek su kelių failų suspaudimu.

Aspose.ZIP paketą galima pridėti prie jūsų .NET projekto naudojant šią NuGet komandą:

PM> Install-Package Aspose.Zip

Kaip suspausti vieną failą naudojant C#

Pirmiausia reikia sukurti FileStream objektą išvestiniam ZIP archyvui.
Įkelti vieną failą į FileStream objektą.
Sukurti Archive klasės objektą.
Pridėti failą į archyvą naudojant metodą Archive.CreateEntry („FileName“, FileStream).
Išsaugoti ZIP archyvą naudojant metodą 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);
        }
    }
}

Kaip suspausti kelis failus naudojant C#

Skirtumas tarp vieno ir kelių failų suspaudimo yra tas, kad reikia įkelti daugiau failų į FileStream ir visus juos pridėti į ZIP archyvą naudojant metodą Archive.CreateEntry(“FileName”, FileStream).

Toliau pateiktas kodo fragmentas rodo, kaip pridėti kelis failus į ZIP naudojant 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" });
            }
        }
    }
}

Suspausti failus naudojant FileInfo klasę

Failus taip pat galima įkelti naudojant FileInfo klasę ir vėliau pridėti į ZIP archyvą taip pat, kaip anksčiau.

FileInfo klasė suteikia savybes ir metodus failų kūrimui, kopijavimui, ištrynimui, perkėlimui ir atidarymui, bei padeda kurti FileStream objektus.

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

Saugojimas archyvuose be suspaudimo

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

Kaip suspausti ZIP failus su slaptažodžiu C# kalboje

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

Parametras encryptionSettings naudojamas kuriant slaptažodžiu apsaugotą ZIP archyvą.

Kaip išskleisti ZIP failus su slaptažodžiu C# kalboje

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

ArchiveLoadOptions su DecryptionPassword savybe naudojama atidarant slaptažodžiu apsaugotą ZIP archyvą.

Visus pilnus pavyzdžius ir duomenų failus rasite čia: https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

LZMA suspaudimo naudojimas ZIP archyve

Lempel–Ziv–Markov grandinės algoritmas (LZMA) yra algoritmas, naudojamas beprarastiniam duomenų suspaudimui. LZMA naudoja žodyno suspaudimo metodą, o suspaustas srautas yra bitų srautas. LZMA suspaudimas ZIP archyve leidžia ZIP konteineriams turėti LZMA suspaustus įrašus. Žemiau pateiktas kodo pavyzdys rodo LZMA suspaudimo įgyvendinimą naudojant 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 suspaudimo naudojimas ZIP archyve

bzip2 yra laisva ir atviro kodo failų suspaudimo programa, kuri naudoja Burrows–Wheeler algoritmą. Ji suspaudžia tik atskirus failus ir nėra failų archyvavimo įrankis. Sukūrė ją Julianas Seward, o prižiūri Markas Wielaardas ir Micah Snyder. Žemiau pateiktas kodo fragmentas rodo BZip2 suspaudimo įgyvendinimą naudojant 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 suspaudimo naudojimas ZIP archyve

Partial Matching (PPM) – tai adaptacinė statistinė duomenų suspaudimo technika, paremta konteksto modeliavimu ir prognozavimu. PPM modeliai naudoja ankstesnių simbolių rinkinį nesuspaustame simbolių sraute, kad prognozuotų kitą simbolį. PPM algoritmai taip pat gali būti naudojami duomenų grupavimui klasterizacijos analizėje. Žemiau pateiktas kodo fragmentas rodo PPMd suspaudimo įgyvendinimą naudojant 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);
    }
}

Išskleisti archyvą su vienu failu

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

Išskleisti archyvą su keliais failais

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

Išgauti saugomą archyvą be suspaudimo

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

Visus pilnus pavyzdžius ir duomenų failus rasite čia: https://github.com/aspose-zip/Aspose.ZIP-for-.NET .