Wissensdatenbank

ZIP- oder Entzippen von Dateien mit C# – Dateikomprimierung und -dekomprimierung

Was ist ZIP (Dateiformat)

ZIP ist ein Archivdateiformat, das verlustfreie Datenkompression unterstützt. Eine ZIP‑Datei kann eine oder mehrere Dateien bzw. Verzeichnisse enthalten, die komprimiert wurden. ZIP‑Dateien verwenden in der Regel die Dateierweiterungen .zip oder .ZIP und den MIME‑Typ application/zip. Viele Programme nutzen ZIP als Basisdateiformat, häufig unter einem anderen Namen. In grafischen Benutzeroberflächen wird das Symbol für ZIP‑Dateien oft als Dokument oder ein Objekt mit einem sichtbaren Reißverschluss dargestellt.

Es gibt mehrere Möglichkeiten, Dateien zu zippen (komprimieren) , abhängig vom verwendeten Betriebssystem. Und fast täglich müssen wir Dateien zippen oder entzippen und sie an einen Speicher‑Server oder eine Dateifreigabe‑Plattform weiterleiten. Zum Glück lässt sich dieser Vorgang mit der Aspose.ZIP API automatisieren. Sie ermöglicht das Komprimieren und Dekomprimieren von Dateien, ohne sich um die zugrunde liegende Dateistruktur kümmern zu müssen. Dieser Artikel zeigt, wie man sowohl einzelne als auch mehrere Dateien komprimiert.

Aspose.ZIP‑Paket kann Ihrem .NET‑Projekt mit folgendem NuGet‑Befehl hinzugefügt werden:

PM> Install-Package Aspose.Zip

Wie man eine einzelne Datei mit C# komprimiert

  1. Zuerst müssen wir ein Objekt der FileStream‑Klasse für das Ausgabe‑ZIP‑Archiv erstellen.
  2. Laden Sie eine einzelne Datei in das FileStream ‑Objekt.
  3. Erzeugen Sie ein Objekt der Archive‑Klasse .
  4. Fügen Sie die Datei mit der Methode Archive.CreateEntry („Dateiname“, FileStream) zum Archiv hinzu.
  5. Speichern Sie das ZIP‑Archiv mit der Methode 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);
                }
            }
        }

Mehrere Dateien mit C# komprimieren

Der Unterschied zwischen dem Komprimieren einer einzelnen Datei und mehrerer Dateien besteht darin, dass wir mehrere Dateien in den FileStream laden und sie alle mit der Methode Archive.CreateEntry("Dateiname", FileStream) zum ZIP‑Archiv hinzufügen müssen. Der folgende Code‑Abschnitt zeigt, wie mehrere Dateien mit FileStream hinzugefügt werden.

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

Dateien mit der FileInfo‑Klasse komprimieren

Dateien können auch über die FileInfo‑Klasse geladen und anschließend wie zuvor zum ZIP‑Archiv hinzugefügt werden. Die FileInfo‑Klasse stellt Eigenschaften und Instanzmethoden für das Erstellen, Kopieren, Löschen, Verschieben und Öffnen von Dateien bereit und erleichtert die Erstellung von FileStream‑Objekten.

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

Dateien ohne Kompression im Archiv speichern

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

ZIP‑Dateien mit Passwort in C# erstellen

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

Der Parameter encryptionSettings wird verwendet, um ein passwortgeschütztes ZIP‑Archiv zu erzeugen.

ZIP‑Dateien mit Passwort in C# entpacken

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

Die ArchiveLoadOptions mit dem Property DecryptionPassword werden genutzt, um ein passwortgeschütztes ZIP‑Archiv zu öffnen.

Für vollständige Beispiele und Beispieldateien besuchen Sie bitte https://github.com/aspose-zip/Aspose.ZIP-for-.NET .

LZMA‑Kompression innerhalb eines ZIP‑Archivs verwenden

Der Lempel–Ziv–Markov‑Ketten‑Algorithmus (LZMA) ist ein Verfahren zur verlustfreien Datenkompression. LZMA nutzt ein Wörterbuch‑Kompressionsverfahren, bei dem der komprimierte Strom aus Bits besteht. LZMA‑Kompression innerhalb eines ZIP‑Archivs ermöglicht es, LZMA‑komprimierte Einträge zu speichern. Das folgende Beispiel demonstriert die Implementierung von LZMA‑Kompression mit der 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‑Kompression innerhalb eines ZIP‑Archivs verwenden

bzip2 ist ein freies, quelloffenes Kompressionsprogramm, das den Burrows–Wheeler‑Algorithmus nutzt. Es komprimiert nur einzelne Dateien und ist kein Archivierungswerkzeug. Entwickelt wurde es von Julian Seward und wird von Mark Wielaard sowie Micah Snyder gepflegt. Das folgende Code‑Snippet zeigt die Implementierung von BZip2‑Kompression mit der 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‑Kompression innerhalb eines ZIP‑Archivs verwenden

Prediction by Partial Matching (PPM) ist eine adaptive, statistische Datenkompressionstechnik, die auf Kontext‑Modellierung und Vorhersage basiert. PPM‑Modelle nutzen frühere Symbole im unkomprimierten Strom, um das nächste Symbol vorherzusagen. Das folgende Beispiel demonstriert die Implementierung von PPMd‑Kompression mit der 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);
    }
}

Einzelne Datei aus einem Archiv dekomprimieren

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

Mehrere Dateien aus einem Archiv dekomprimieren

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

Archiv ohne Kompression extrahieren

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 vollständige Beispiele und Beispieldateien besuchen Sie bitte https://github.com/aspose-zip/Aspose.ZIP-for-.NET .