Zip vai unzip failus, izmantojot C# – Failu saspiešana un atspiešana

Kas ir ZIP (faila formāts)

ZIP ir arhīva faila formāts, kas atbalsta bezzaudējumu datu saspiešanu. ZIP fails var saturēt vienu vai vairākus failus vai direktorijus, kas ir saspiesti. ZIP faili parasti izmanto faila paplašinājumus .zip vai .ZIP un MIME mediju tipu application/zip. Daudzas programmas izmanto ZIP kā pamata faila formātu, bieži vien zem citām nosaukuma variācijām. Navigējot failu sistēmā caur lietotāja saskarni, grafiskās ikonas, kas pārstāv ZIP failus, bieži izskatās kā dokuments vai cits objekts, kurā izceltas rāvējslēdzēja detaļas.
Ir daudzas iespējas zip (saspiešanai) failiem , atkarībā no operētājsistēmas, ko lietojat. Un gandrīz katru dienu mums jāzip vai jāunzip kādi faili, lai tos nosūtītu uz krātuves serveri vai failu apmaiņas platformu. Par laimi, šo procesu var automatizēt, izmantojot Aspose.ZIP API . Tas ļauj saspiest un atspiest failus, nerūpējoties par pamatā esošo struktūru. Šis raksts parāda, kā strādāt gan ar vienu, gan ar vairākiem failiem saspiešanai.
Aspose.ZIP pakotni var pievienot jūsu .NET projektam, izmantojot šādu NuGet komandu:

PM> Install-Package Aspose.Zip

Kā saspiest vienu failu, izmantojot C#

Vispirms jāizveido FileStream objekts izvadīšanas ZIP arhīvam.
Ielādēt vienu failu FileStream objektā.
Izveidot Archive klases objektu.
Pievienot failu arhīvam, izmantojot Archive.CreateEntry (“FileName”, FileStream) metodi.
Izveidot ZIP arhīvu, izmantojot Archive.Save(FileStream) metodi.

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

Vairāku failu saspiešana, izmantojot C#

Atšķirība starp viena un vairāku failu saspiešanu ir tāda, ka jāielādē vairākas FileStream instances un jāpiešķir tās visām ZIP arhīva ierakstiem, izmantojot metodi Archive.CreateEntry(“FileName”, FileStream).
Tālāk redzams koda fragments, kas parāda, kā pievienot vairākus failus ZIP, izmantojot 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" });
		            	}
		        }
	        }
        }

Failu saspiešana, izmantojot FileInfo klasi

Failus var arī ielādēt, izmantojot FileInfo klasi, un pēc tam pievienot ZIP arhīvam tāpat kā iepriekš.
FileInfo klase nodrošina īpašības un instance metodes failu izveidei, kopēšanai, dzēšanai, pārvietošanai un atvēršanai, kā arī palīdz izveidot 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 });
	        }
    }

Failu glabāšana arhīvos bez saspiešanas

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

Kā izveidot ZIP failus ar paroli, izmantojot 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");
    }

Parametrs encryptionSettings tiek izmantots, lai izveidotu ar paroli aizsargātu ZIP arhīvu.

Kā atspiest ZIP failus ar paroli, izmantojot C#

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

ArchiveLoadOptions ar DecryptionPassword īpašību tiek izmantots, lai atvērtu ar paroli aizsargātu ZIP arhīvu.
Lai apskatītu pilnus piemērus un datu failus, apmeklējiet https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

LZMA saspiešana ZIP arhīvā

Lempel–Ziv–Markova ķēdes algoritms (LZMA) ir algoritms, kas veic bezzaudējumu datu saspiešanu. LZMA izmanto vārdnīcas saspiešanas metodi, un saspiestais plūsmas dati ir bitu plūsma. LZMA saspiešana ZIP arhīvā ļauj ZIP konteineriem saturēt LZMA saspiestus ierakstus. Zemāk redzams koda piemērs, kas demonstrē LZMA saspiešanu, izmantojot 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 saspiešana ZIP arhīvā

bzip2 ir brīvi pieejama un atvērtā koda failu saspiešanas programma, kas izmanto Burrows–Wheeler algoritmu. Tā spēj saspiest tikai atsevišķus failus un nav failu arhivators. To izstrādāja Julian Seward, un uztur Mark Wielaard un Micah Snyder. Zemāk redzams koda fragments, kas demonstrē BZip2 saspiešanu, izmantojot 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 saspiešana ZIP arhīvā

Partial Matching (PPM) ir adaptīva statistiska datu saspiešanas tehnika, kas balstīta uz konteksta modelēšanu un prognozēšanu. PPM modeļi izmanto iepriekšējo simbolu kopu nekompresētajā simbolu plūsmā, lai prognozētu nākamo simbolu. PPM algoritmi var tikt izmantoti arī datu grupēšanai klasteru analīzē. Zemāk redzams koda fragments, kas demonstrē PPMd saspiešanu, izmantojot 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);
    }
}

Vienas faila atspiešana no arhīva

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

Vairāku failu atspiešana no arhīva

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

Glabāto arhīvu atspiešana bez saspiešanas

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

Lai apskatītu pilnus piemērus un datu failus, apmeklējiet https://github.com/aspose-zip/Aspose.ZIP-for-.NET .