Bază de cunoștințe

Comprimă sau decomprimă fișiere utilizând C# - Compresie și decompresie fișiere

Ce este ZIP (format de fișier)

ZIP este un format de fișier arhivă care suportă compresie fără pierderi de date. Un fișier ZIP poate conține unul sau mai multe fișiere sau directoare care au fost comprimate. Fișierele ZIP folosesc în general extensiile .zip sau .ZIP și tipul MIME application/zip. ZIP este utilizat ca format de bază de către multe programe, de obicei sub un alt nume. Când navigați un sistem de fișiere printr-o interfață grafică, pictogramele care reprezintă fișierele ZIP apar adesea ca un document sau alt obiect care evidențiază un fermoar.

Există mai multe moduri de a comprima (zip) fișiere , în funcție de sistemul de operare pe care îl utilizați. Și aproape în fiecare zi trebuie să comprimăm sau să decomprimăm fișiere și să le trimitem către un server de stocare sau o platformă de partajare a fișierelor. Din fericire, putem automatiza acest proces utilizând Aspose.ZIP API . Acesta vă permite să comprimați și să decomprimați fișiere fără să vă faceți griji cu privire la structura de bază a fișierelor. Acest articol prezintă lucrul cu compresia unui singur fișier, precum și cu compresia multiplă.

Pachetul Aspose.ZIP poate fi adăugat proiectului dvs. .NET utilizând următoarea comandă NuGet:

PM> Install-Package Aspose.Zip

Cum să comprimați un singur fișier cu C#

  1. Mai întâi trebuie să creăm un obiect al clasei FileStream pentru arhiva ZIP de ieșire
  2. Încărcați un singur fișier în obiectul FileStream
  3. Creați un obiect al clasei Archive
  4. Adăugați fișierul în arhivă utilizând metoda Archive.CreateEntry ( “FileName”, FileStream)
  5. Creați arhiva ZIP utilizând metoda 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);
                }
            }
        }

Comprimarea mai multor fișiere cu C#

Diferența dintre comprimarea unui singur fișier și a mai multor fișiere constă în faptul că trebuie să încărcăm mai multe fișiere în FileStream și să le adăugăm pe toate în arhiva ZIP utilizând metoda Archive.CreateEntry("FileName", FileStream).
Următorul fragment de cod arată cum să adăugați mai multe fișiere în ZIP utilizând 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" });
		            	}
		        }
	        }
        }

Comprimarea fișierelor utilizând clasa FileInfo

Fișierele pot fi încărcate și prin clasa FileInfo și apoi adăugate în arhiva ZIP în același mod ca mai înainte.
Clasa FileInfo oferă proprietăți și metode de instanță pentru crearea, copierea, ștergerea, mutarea și deschiderea fișierelor și facilitează crearea obiectelor FileStream.

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

Stocarea fișierelor în arhive fără compresie

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

Cum să comprimați fișiere ZIP cu parolă în 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");
    }

Parametrul encryptionSettings este utilizat pentru a crea o arhivă ZIP protejată prin parolă.

Cum să decomprimați fișiere ZIP cu parolă în C#

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

ArchiveLoadOptions cu proprietatea DecryptionPassword este folosită pentru a deschide o arhivă ZIP protejată prin parolă.
Pentru a vedea exemple complete și fișiere de date, vă rugăm să accesați https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

Utilizarea compresiei LZMA în arhiva ZIP

Algoritmul Lempel–Ziv–Markov (LZMA) este un algoritm utilizat pentru a efectua compresie fără pierderi de date. LZMA folosește un algoritm de compresie pe bază de dicționar, fluxul comprimat fiind un flux de biți. Compresia LZMA în interiorul arhivei ZIP permite containerelor ZIP să conțină intrări comprimate cu LZMA. Următorul exemplu de cod arată implementarea compresiei LZMA utilizând 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);
    }
}

Utilizarea compresiei BZip2 în arhiva ZIP

bzip2 este un program gratuit și open‑source de compresie a fișierelor care folosește algoritmul Burrows–Wheeler. Compresă doar fișiere individuale și nu este un arhivator de fișiere. A fost dezvoltat de Julian Seward și este întreținut de Mark Wielaard și Micah Snyder. Următorul fragment de cod arată implementarea compresiei BZip2 utilizând 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);
    }
}

Utilizarea compresiei PPMd în arhiva ZIP

Predicția prin potrivire parțială (PPM) este o tehnică adaptivă de compresie statistică a datelor bazată pe modelarea contextului și predicție. Modelele PPM utilizează un set de simboluri anterioare din fluxul de simboluri necomprimate pentru a prezice următorul simbol din flux. Algoritmii PPM pot fi folosiți și pentru a grupa datele în grupări prezise în analiza clusterelor. Următorul fragment de cod arată implementarea compresiei PPMd utilizând 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);
    }
}

Decompresia arhivei cu un singur fișier

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

Decompresia arhivei cu mai multe fișiere

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

Extrageți arhiva stocată fără compresie

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

Pentru exemple complete și fișiere de date, vă rugăm să accesați https://github.com/aspose-zip/Aspose.ZIP-for-.NET .