Pakkaa tai pura tiedostoja C#:lla - Tiedostojen pakkaus ja purku

Mikä on ZIP (tiedostomuoto)

ZIP on arkistotiedostomuoto, joka tukee häviötöntä tietojen pakkausta. ZIP‑tiedosto voi sisältää yhden tai useamman tiedoston tai hakemiston, jotka on pakattu. ZIP‑tiedostoja käytetään yleensä tiedostopäätteillä .zip tai .ZIP ja niiden MIME‑tyyppi on application/zip. ZIP toimii monien ohjelmien perusmuotona, usein eri nimellä. Kun selaillaan tiedostojärjestelmää käyttöliittymän kautta, ZIP‑tiedostoja edustavat graafiset kuvakkeet näkyvät usein asiakirjana tai muuna objektina, jossa on selvästi esillä vetoketju.

On olemassa useita tapoja pakata (pakkaus) tiedostoja , riippuen käyttöjärjestelmästä. Lähes joka päivä meidän täytyy pakata tai purkaa tiedostoja ja siirtää ne tallennuspalvelimelle tai tiedostonjakopalveluun. Onneksi prosessi voidaan automatisoida käyttäen Aspose.ZIP API . Se mahdollistaa tiedostojen pakkaamisen ja purkamisen huolehtimatta taustarakenteesta. Tämä artikkeli näyttää, miten työskennellä sekä yksittäisen että useiden tiedostojen pakkaamisen kanssa.

Aspose.ZIP‑paketti voidaan lisätä .NET‑projektiisi seuraavalla NuGet‑komennolla:

PM> Install-Package Aspose.Zip

Kuinka pakata yksittäinen tiedosto C#:lla

Ensiksi meidän täytyy luoda FileStream-luokan objekti tulostus‑ZIP‑arkistolle
Lataa yksittäinen tiedosto FileStream -objektiin
Luo Archive-luokan objekti
Lisää tiedosto arkistoon käyttämällä Archive.CreateEntry ‑menetelmää (“FileName”, FileStream)
Luo ZIP‑arkisto käyttämällä Archive.Save (FileStream)‑menetelmää

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

Useiden tiedostojen pakkaaminen C#:lla

Yksittäisen tiedoston ja useiden tiedostojen pakkaamisen ero on se, että meidän täytyy ladata useampia tiedostoja FileStreamiin ja lisätä ne kaikki ZIP‑arkistoon käyttäen metodia Archive.CreateEntry("FileName", FileStream).

Seuraava koodinpätkä näyttää, miten useita tiedostoja lisätään ZIP‑arkistoon FileStreamin avulla.

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

Tiedostojen pakkaaminen FileInfo-luokalla

Tiedostoja voidaan myös ladata FileInfo‑luokan avulla ja lisätä ZIP‑arkistoon samalla tavalla kuin aiemmin.

FileInfo‑luokka tarjoaa ominaisuuksia ja instanssimenetelmiä tiedostojen luomiseen, kopiointiin, poistamiseen, siirtämiseen ja avaamiseen, sekä auttaa FileStream‑objektien luomisessa.

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

Tiedostojen tallentaminen arkistoihin ilman pakkausta

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

Kuinka pakata ZIP‑tiedostoja salasanalla C#:lla

    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‑parametria käytetään luomaan salasanasuojattu ZIP‑arkisto.

Kuinka purkaa ZIP‑tiedostoja salasanalla C#:lla

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

ArchiveLoadOptions‑luokan DecryptionPassword‑ominaisuutta käytetään avaamaan salasanasuojattu ZIP‑arkisto.
Katso täydelliset esimerkit ja datatiedostot osoitteessa https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

LZMA-pakkauksen käyttö ZIP‑arkistossa

Lempel–Ziv–Markov‑ketjualgoritmi (LZMA) on häviötöntä tietojen pakkausta suorittava algoritmi. LZMA käyttää sanakirjapohjaista pakkausmenetelmää, ja pakattu virta koostuu biteistä. LZMA‑pakkaus ZIP‑arkistossa mahdollistaa ZIP‑konttien sisältää LZMA‑pakattuja kohteita. Seuraava koodiesimerkki näyttää LZMA‑pakkauksen toteutuksen käyttäen 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-pakkauksen käyttö ZIP‑arkistossa

bzip2 on ilmainen ja avoimen lähdekoodin tiedostopakkausohjelma, joka käyttää Burrows–Wheeler‑algoritmia. Se pakkaa vain yksittäisiä tiedostoja eikä toimi arkistointiohjelmana. Ohjelman on kehittänyt Julian Seward, ja sitä ylläpitävät Mark Wielaard ja Micah Snyder. Seuraava koodinpätkä näyttää BZip2‑pakkauksen toteutuksen käyttäen 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-pakkauksen käyttö ZIP‑arkistossa

Partial‑Matching‑menetelmään (PPM) perustuva adaptiivinen tilastollinen tietojen pakkaustekniikka käyttää kontekstimallinnusta ja ennustamista. PPM‑mallit hyödyntävät edellisiä symboleja pakkaamattomassa symbolivirrassa ennustaakseen seuraavan symbolin. PPM‑algoritmeja voidaan myös käyttää ryhmittämään dataa ennustettuihin ryhmiin klusterianalyysissä. Seuraava koodinpätkä näyttää PPMd‑pakkauksen toteutuksen käyttäen 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);
    }
}

Arkiston purkaminen yksittäisellä tiedostolla

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

Arkiston purkaminen useilla tiedostoilla

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

Tallennetun arkiston purkaminen ilman pakkausta

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

Katso täydelliset esimerkit ja datatiedostot osoitteessa https://github.com/aspose-zip/Aspose.ZIP-for-.NET .